The command
ogr2ogr -f GeoJSON out.json BGRI2021_0706.gpkg
returns
ERROR 1: database disk image is malformed
FAILURE:
Unable to open datasource `BGRI2021_0706.gpkg' with the following drivers.
-> `FITS'
-> `PCIDSK'
-> `netCDF'
-> `PDS4'
-> `VICAR'
-> `JP2OpenJPEG'
-> `PDF'
-> `MBTiles'
-> `BAG'
-> `EEDA'
-> `OGCAPI'
-> `ESRI Shapefile'
-> `MapInfo File'
-> `UK .NTF'
-> `LVBAG'
-> `OGR_SDTS'
-> `S57'
-> `DGN'
-> `OGR_VRT'
-> `REC'
-> `Memory'
-> `CSV'
-> `NAS'
-> `GML'
-> `GPX'
-> `LIBKML'
-> `KML'
-> `GeoJSON'
-> `GeoJSONSeq'
-> `ESRIJSON'
-> `TopoJSON'
-> `Interlis 1'
-> `Interlis 2'
-> `OGR_GMT'
-> `GPKG'
-> `SQLite'
-> `ODBC'
-> `WAsP'
-> `PGeo'
-> `MSSQLSpatial'
-> `OGR_OGDI'
-> `PostgreSQL'
-> `MySQL'
-> `OpenFileGDB'
-> `DXF'
-> `CAD'
-> `FlatGeobuf'
-> `Geoconcept'
-> `GeoRSS'
-> `GPSTrackMaker'
-> `VFK'
-> `PGDUMP'
-> `OSM'
-> `GPSBabel'
-> `OGR_PDS'
-> `WFS'
-> `OAPIF'
-> `SOSI'
-> `Geomedia'
-> `EDIGEO'
-> `SVG'
-> `CouchDB'
-> `Cloudant'
-> `Idrisi'
-> `ARCGEN'
-> `XLS'
-> `ODS'
-> `XLSX'
-> `Elasticsearch'
-> `Walk'
-> `Carto'
-> `AmigoCloud'
-> `SXF'
-> `Selafin'
-> `JML'
-> `PLSCENES'
-> `CSW'
-> `VDV'
-> `GMLAS'
-> `MVT'
-> `NGW'
-> `MapML'
-> `TIGER'
-> `AVCBin'
-> `AVCE00'
-> `HTTP'
I am in the correct directory and the file exists
ll BGRI2021_0706.gpkg -h
-rw-r--r-- 1 joao joao 1,1M nov 28 18:07 BGRI2021_0706.gpkg
ogr2ogr support the format:
$ ogrinfo --formats | grep GPKG
GPKG -raster,vector- (rw+vs): GeoPackage
I am using v3.3.2
$ ogr2ogr --version
GDAL 3.3.2, released 2021/09/01
Related
#include <iostream>
#include <time.h>
#include <list>
using namespace std;
void PareY();
void PareA();
void PareB();
void PareE();
static list<string> s;
void showlist(list<string> g)
{
list<string>::iterator it;
for (it = g.begin(); it != g.end(); ++it)
cout << ' ' << *it;
cout << '\n';
}
int main() {
time_t t;
srand((unsigned) time(&t));
cout << "<E>::=(<Y>)" << endl;
cout << "<Y>::=<A><B>" << endl;
cout << "<A>::=ν|<Ε>" << endl;
cout << "<Β>::=-<Υ>|+<Υ>|ε" << endl;
PareE();
cout << "---------------" << endl;
showlist(s);
return 0;
}
void PareE(){
cout << "E -> (Y)" << endl;
s.push_back("(");
PareY();
s.push_back(")");
}
void PareY(){
cout << "Y -> AB" << endl;
PareA();
PareB();
}
void PareA(){
if((rand() % 2 ) == 0){
cout << "A -> ν" << endl;
s.push_back("ν");
}else{
cout << "A -> E" << endl;
PareE();
}
}
void PareB(){
if((rand() % 3) == 0){
cout << "B -> -Y" << endl;
s.push_back("-");
PareY();
}
else if((rand() % 3) == 1){
cout << "B -> +Y" << endl;
s.push_back("+");
PareY();
}else{
cout << "B -> ε" << endl;
}
}
I have to create strings based on the grammar seen in the couts in the main function.
When i run tests, it sometimes prints stuff nonstop (it only stops if i hit the stop) why is that?
I have to show the steps as well e.x E -> (Y) -> (AB) -> (νB) -> (ν-Y) -> (ν-(ΑΒ)) and so on instead of what i've done (i'm just showing the production rule) and i don't know how to do that. I'm using a list there just for the outcome but should i use a list as well for the production? I don't know how else to do it.
<E>::=(<Y>)
<Y>::=<A><B>
<A>::=ν|<Ε>
<Β>::=-<Υ>|+<Υ>|ε
E -> (Y)
Y -> AB
A -> ν
B -> ε
---------------
( ν )
That's an example. It should be something like E -> (Y) -> (AB) -> (νΒ) -> (ν). The only thing i can think of is having a list storing the current string..
The grammar has recursions. That is the reason, why it may continue long.
For example can call again recursivly. And so on and so on. Depending on the random number. In it will quite often happen that it runs until stack overflow :-) The grammar is rather explosiv...
And if we show the states in a recursive decent way, we can just output the state in the nonterminal function. But I am not sure if that is what you want. I put the characters of the string in a vector. But, whatver container is ok.
The only terminals that you have are 'v', '+' and '-'.
#include <iostream>
#include <time.h>
#include <vector>
using namespace std;
void PareY();
void PareA();
void PareB();
void PareE();
vector<vector<char>> strings{};;
int main() {
strings.push_back({});
time_t t;
srand((unsigned)time(&t));
cout << "<E>::=(<Y>)" << endl;
cout << "<Y>::=<A><B>" << endl;
cout << "<A>::=ν|<Ε>" << endl;
cout << "<Β>::=-<Υ>|+<Υ>|epsilon" << endl;
cout << "\n\n---------------\n\nStart ";
PareE();
cout << "---------------\n\nStrings:\n\n" << endl;
for (const auto& s : strings) {
for (const char c : s) std::cout << c;
std::cout << '\n';
}
return 0;
}
void PareE() {
cout << " -> (E)";
PareY();
}
void PareY() {
cout << " -> (Y)";
PareA();
PareB();
}
void PareYPlus() {
cout << " -> +(Y)";
PareA();
PareB();
}
void PareYMinus() {
cout << " -> -(Y)";
PareA();
PareB();
}
void PareA() {
cout << " -> (A)";
if ((rand() % 2) == 0) {
cout << " -> v";
strings.back().push_back('v');
}
else {
PareE();
}
}
Potential output:
<E>::=(<Y>)
<Y>::=<A><B>
<A>::=ν|<Ε>
<Β>::=-<Υ>|+<Υ>|epsilon
---------------
Start -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> +(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> (E) -> (Y) -> (A) -> (E) -> (Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon -> (B) -> -(Y) -> (A) -> v -> (B) -> -(Y) -> (A) -> v -> (B) -> +(Y) -> (A) -> v -> (B) -> epsilon -> (B) -> epsilon---------------
Strings:
v-v-v+v
-v
-v-v+v+v
+v+v+v
+v-v
-v-v-v+v
-v-v
-v-v+v
+v-v-v+v
+v
-v-v-v
-v-v
-v-v+v+v-v+v+v-v
As a pass-time, I'm trying to implement all kinds of problems that were presented in a course (concerned with Lambda Calculus and various programming concepts) I took at the university. So, I'm trying to implement Church numerals and associated operators in OCaml (also as an exercise in OCaml).
This is the code so far:
let church_to_int n =
n (fun x -> x + 1) 0;;
let succ n s z =
s (n s z)
let zero = fun s z -> z
let int_to_church i =
let rec compounder i cont =
match i with
| 0 -> cont zero
| _ -> compounder (i - 1) (fun res -> cont (succ res))
in
compounder i (fun x -> x)
let add a b = (b succ) a
let mul a b = (b (add a)) zero
So, it seems to work, but then it breaks down. Let's consider these definitions:
let three = int_to_church 3
let four = int_to_church 4
church_to_int (add three four) // evaluates to 7
church_to_int (add four three) // throws type error - see later
I get that the error thrown has to do with the type polymorphism of the Church numerals when they're defined (see SO question), and then it's resolved after the closures are invoked once. However, I don't seem to understand why the type inconsistency error is thrown in this case:
let three = int_to_church 3
let four = int_to_church 4
church_to_int (mul three four) // throws type error - see later
Any thoughts?
The specific errors:
1.
Error: This expression has type (int -> int) -> int -> int but an expression was expected of type ((('a -> 'b) -> 'c -> 'a) -> ('a -> 'b) -> 'c -> 'b) ->
((((int -> int) -> int -> int) -> (int -> int) -> int -> int) ->
((int -> int) -> int -> int) -> (int -> int) -> int -> int) ->
'd
Type int is not compatible with type ('a -> 'b) -> 'c -> 'a
2.
Error: This expression has type ((((('a -> 'b) -> 'c -> 'a) -> ('a -> 'b) -> 'c -> 'b) -> (('d -> 'd) -> 'd -> 'd) -> 'e) ->
((('a -> 'b) -> 'c -> 'a) -> ('a -> 'b) -> 'c -> 'b) ->
(('d -> 'd) -> 'd -> 'd) -> 'e) ->
(((('a -> 'b) -> 'c -> 'a) -> ('a -> 'b) -> 'c -> 'b) ->
(('d -> 'd) -> 'd -> 'd) -> 'e) ->
((('a -> 'b) -> 'c -> 'a) -> ('a -> 'b) -> 'c -> 'b) ->
(('d -> 'd) -> 'd -> 'd) -> 'e
but an expression was expected of type
((((('a -> 'b) -> 'c -> 'a) -> ('a -> 'b) -> 'c -> 'b) ->
(('d -> 'd) -> 'd -> 'd) -> 'e) ->
'e) ->
('f -> 'g -> 'g) -> 'h
The type variable 'e occurs inside
((('a -> 'b) -> 'c -> 'a) -> ('a -> 'b) -> 'c -> 'b) ->
(('d -> 'd) -> 'd -> 'd) -> 'e
Well i was a bit rusty with lambda-calculus, but after few discussions with some wise old men, i came to this answer : YES, writing that way, OCaml's type system do not allow the writing of Church numerals.
The real problem here is with your addition term :
let add a b = b succ a
wich has the following type
(((('a -> 'b) -> 'c -> 'a) -> ('a -> 'b) -> 'c -> 'b) -> 'd -> 'e) -> 'd -> 'e
Where the arguments of add have not the same type. This is a bit sad since we naively expect the addition to be commutative.
You can easily verify this when writing :
let double a = add a a (* produces type error - the type variable occurs ... *)
This error means that you're trying to unify one type with a "bigger" type i.e that contains it (ex: unifying 'a with 'a -> 'a). OCaml does not allow that (unless if you set the -rectypes option wich allows cyclic types).
To understand better what's going on, let's add type annotations to help the typer (i'll change a bit your notations for sake of clarity):
type 'a church = ('a -> 'a) -> 'a -> 'a
let zero : 'a church = fun f x -> x
let succ n : 'a church = fun f x -> f (n f x)
Now let's go back to the add term and annotate it a bit to see what the typer has to say:
let add (a:'a church) b = a succ b (* we only annotate "a" to let the typer infer the rest *)
This produces a very odd type :
'a church church -> 'a church -> 'a church
That gets interesting: why is the first arg typed as an 'a church church?
The answer is the following : Here, a church integer is a value that takes a moving function of type 'a -> 'a (a self-map in mlahematics) that can browse a space, and an starting point ('a) that belongs to that space.
Here, if we specify that the parameter a has type 'a church, than 'a represent the space in which we can move.
Since succ, the moving function of a, operates over the church, than 'a here is it self an 'a church, thus making the parameter a an 'a church church.
This is not at all the type we wanted at the begining ... but that justifies why the type system do not allow your values three and four as both 1st and snd argument of add.
One solution can be to write add in a different way :
let add a b f x = a f (b f x)
Here, both a and b have the same moving function, and thus the same type, but you do not enjoy anymore the beautiful writing with the partial application ...
An other solution which makes you keep this beautiful writing would be to use universal types, that allow a larger kind of polymorphism:
type nat = {f:'a.('a -> 'a) -> 'a -> 'a}
(* this means “for all types ‘a” *)
let zero : nat = {
f=fun f x -> x
}
let succ n : nat = {
f= fun f x -> f (n.f f x)
}
let add (a:nat) (b:nat) = a.f succ b
let double a = add a a (* Now this has a correct type *)
let nat_to_int n =
n.f (fun x -> x + 1) 0;;
let nat_four = succ (succ (succ (succ zero)))
let eight_i = double nat_four |> nat_to_int //returns 8
But this solution is a bit more verbose than your initial one.
Hope it was clear.
If you look at the type of three, you get that:
val three : ('_a -> '_a) -> '_a -> '_a = <fun>
This is simply the value restriction at work. The value restriction is well explained here: https://realworldocaml.org/v1/en/html/imperative-programming-1.html#side-effects-and-weak-polymorphism
To solve it, In this case you can simply eta-expand the function:
let three x = int_to_church 3 x ;;
val three : ('a -> 'a) -> 'a -> 'a = <fun>
I've just noticed the following functions in Lwt.mli:
val backtrace_bind : (exn -> exn) -> 'a t -> ('a -> 'b t) -> 'b t
val backtrace_catch : (exn -> exn) -> (unit -> 'a t) -> (exn -> 'a t) -> 'a t
val backtrace_try_bind : (exn -> exn) -> (unit -> 'a t) -> ('a -> 'b t) -> (exn -> 'b t) -> 'b t
val backtrace_finalize : (exn -> exn) -> (unit -> 'a t) -> (unit -> unit t) -> 'a t
Unfortunately they are undocumented. What do they do?
Some digging in GitHub and documentation shows that these are used internally for propagating backtraces between threads when using pa_lwt and -lwt-debug is passed to camlp4. They are also used for the same purpose by default with ppx_lwt.
The -lwt-debug option is documented on this page: http://ocsigen.org/lwt/2.5.0/manual/ (search the page for "backtrace support" to go to it).
The option to turn this off in ppx_lwt is documented here: https://ocsigen.org/lwt/dev/api/Ppx_lwt (search for -no-debug).
See this commit, which shows that these are used in the code generated by try_lwt, etc.: https://github.com/ocsigen/lwt/commit/78eee34fb6247da38a3d4ea5b7872676181d47e2
Edited: confirmed more things by looking through more code, and incorporated comment.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 8 years ago.
Improve this question
Is someone may explain me functors. I would like to simple examples. When we should use functors?
Functors, essentially are a way to write modules in terms of other modules.
A pretty classic example is the Map.Make functor from the standard library. This functor lets you define a map with a specific key type.
Here's a trivial and rather dumb example:
module Color = struct
type t = Red | Yellow | Blue | Green | White | Black
let compare a b =
let int_of_color = function
| Red -> 0
| Yellow -> 1
| Blue -> 2
| Green -> 3
| White -> 4
| Black -> 5 in
compare (int_of_color a) (int_of_color b)
end
module ColorMap = Map.Make(Color)
Loading this in ocaml shows the signature of the generated modules:
module Color :
sig
type t = Red | Yellow | Blue | Green | White | Black
val compare : t -> t -> int
end
module ColorMap :
sig
type key = Color.t
type 'a t = 'a Map.Make(Color).t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
end
The simple module ColorMap = Map.Make(Color) has created a module that implements a map where the keys are colors. It's now possible to call ColorMap.singleton Color.Red 1 and get a map of red to the number 1.
Note that the use of Map.Make worked because the passed module (Color) satisfies the requirements of the Map.Make functor. The docs say the type of the functor is module Make: functor (Ord : OrderedType) -> S with type key = Ord.t. The : OrderedType means that the input module (Color) has to be consistent (I'm sure there's a more official term) with the OrderedType module signature.
To be consistent with OrderedType the input module has to have a type t and a function compare with signature t -> t -> int. In other words there has to be a way to compare values of type t. If you look at the types reported by ocaml that's exactly what Color supplies.
When to use functors is a much more difficult question as often there are several possible designs each with their own trade-offs. But most of the time you'll use functors when a library supplies them as the recommended way of doing something.
Trying to understand Ocaml's mechanism for named parameters. I understand the basics, but the doc shows an example like this:
# let f ~x ~y = x - y;;
val f : x:int -> y:int -> int = <fun>
# let x = 3 and y = 2 in f ~x ~y;;
- : int = 1
What exactly is going on when only the tilde is used in application? Is it just shorthand for ~x:x, similar to definitions? If so, can someone explain why this:
# ListLabels.fold_left;;
- : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a = <fun>
# let add = (+) and i = 0
in ListLabels.fold_left ~add ~i [1;2;3];;
produces
- : f:((add:(int -> int -> int) -> i:int -> 'a) ->
int -> add:(int -> int -> int) -> i:int -> 'a) ->
init:(add:(int -> int -> int) -> i:int -> 'a) -> 'a = <fun>
The man says
"beware that functions like ListLabels.fold_left whose result type is a type variable will never be considered as totally applied."
Here is what happens in your example. Beware it's a bit involved.
# ListLabels.fold_left;;
- : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a = <fun>
is just the classic use: ListLabels.fold_left taks 3 arguments, namely a function labeled f, an initializer init and a list.
Now, in
let add = (+) and i = 0
in ListLabels.fold_left ~add ~i [1;2;3];;
the application ListLabels.fold_left ~add ~i [1;2;3] is considered incomplete (as the man says). That means that `ListLabels.fold_left receives first its unamed argument, [1;2;3] and returns a function of type f:('a -> int -> 'a) -> init:'a -> 'a. Let us call this function foo.
Since you're giving two named arguments, labeled add and i, the type 'a is inferred to be a functional type, of type add:'c -> ~i:'d -> 'e.
Based on the type of the variables add and i, the type 'c must be int -> int -> int, and 'd must be int.
Replacing those values in the type 'a, we derive that the type 'a is add:(int -> int -> int) -> i:int -> 'e.
And replacing this in the type of foo (I'm glad there is copy-pasting ;-), its type is
f:((add:(int -> int -> int) -> i:int -> 'e)
-> int
-> (add:(int -> int -> int) -> i:int -> 'e))
-> init:(add:(int -> int -> int) -> i:int -> 'e)
-> (add:(int -> int -> int) -> i:int -> 'e)
Removing unecessary parentheses, and alpha converting (i.e. renaming) 'e to 'a, we get
f:((add:(int -> int -> int) -> i:int -> 'a)
-> int
-> add:(int -> int -> int) -> i:int -> 'a)
-> init:(add:(int -> int -> int) -> i:int -> 'a)
-> add:(int -> int -> int) -> i:int -> 'a
That is the type of foo. But remember that you are passing two arguments to foo, labeled ~add and ~i. So the value you get at the end is not of type add:(int -> int -> int) -> i:int -> 'a but indeed of type 'a. And the whole type of your example is, as returned by the compiler,
f:((add:(int -> int -> int) -> i:int -> 'a)
-> int
-> add:(int -> int -> int) -> i:int -> 'a)
-> init:(add:(int -> int -> int) -> i:int -> 'a)
-> 'a