There are two potential problems: Inside a signal handler, you can only call asynchronous signal safe functions. Most functions are not async signal safe. The reason for the restriction is that a function could be called in the middle of the same function’s execution. Thus, internal state could be corrupted. Very few functions are async … Read more
This 2009 issue of the Caml weekly news (“CWN”, a digest of interesting messages from the caml list) shows that: the official party line on threads and Ocaml hasn’t changed. A notable quote: (…) in general, the whole standard library is not thread-safe. Probably that should be stated in the documentation for the threads library, … Read more
OCaml tries to force you to separate the interface (.mli) from the implementation (.ml. Most of the time, this is a good thing; for values, you publish the type in the interface, and keep the code in the implementation. You could say that OCaml is enforcing a certain amount of abstraction (interfaces must be published; … Read more
OCaml has two ways of specifying types, they can be done inline: let intEq (x : int) (y : int) : bool = … or they can be placed in an interface file, as you have done: val intEq : int -> int -> bool I believe the latter is preferred, since it more cleanly … Read more
My usage can be divided into the following 5 categories. 1. interface 2. modularity 3. legibility 4. brevity 5. tricks If the variant type is only internal to the module, I use regular variants, because as you said they are compiled more efficiently. If the variant type is exported in the interface and I feel … Read more
You should become familiar with the List.iter and List.map functions. They are essential for programming in OCaml. If you also get comfortable with the Printf module, you can then write: open Printf let a = [1;2;3;4;5] let () = List.iter (printf “%d “) a I open Printf in most of my code because I use … Read more
There are some differences feature-wise, as well as semantically. Features SML supports but not OCaml: transparent signature ascription module-level let symmetric sharing constraints syntactic sugar for functors over types and values Features OCaml 4 has but not SML: higher-order functors recursive modules local modules nested signatures modules as first-class values general module sharing (sig with … Read more
When you define a semantics of function definition, as a language designer, you have choices: either to make the name of the function visible in the scope of its own body, or not. Both choices are perfectly legal, for example C-family languages being far from functional, still do have names of definitions visible in their … Read more
Quick answer: No, that’s beyond the capabilities of current OCaml type inference. To explain it a bit more: type inference in most functional languages is based on a concept called unification, which is really just a specific way of solving equations. For example, inferring the type of an expression like let f l i j … Read more
The semantics for this is the same as in F# (probably because F# is based on OCaml): function allows the use of pattern matching (i.e. |), but consequently it can be passed only one argument. function p_1 -> exp_1 | … | p_n -> exp_n is equivalent to fun exp -> match exp with p_1 … Read more