ocaml

I'm converting some F# code to OCaml and I see a lot of uses of this pipeline operator <| , for example: let printPeg expr = printfn "%s" <| pegToString expr The <| operator is apparently defined as just: # let ( <| ) a b = a b ;; val ( <| ) : ('a -> 'b) -> 'a -> 'b = <fun> I'm wondering why they bother to define and use this operator in F#, is it just so they can avoid putting in parens like this?: let printPeg expr = Printf.printf "%s" ( pegToString expr ) As far as I can tell, that would be the conversion of the F# code above to OCaml, correct? Also, how would I implement F#'s << and >>

One advantage of Reason ML over JavaScript is that it provides a Map type that uses structural equality rather than reference equality. However, I cannot find usage examples of this. For example, how would I declare a type scores that is a map of strings to integers? /* Something like this */ type scores = Map<string, int>; And how would I construct an instance? /* Something like this */ let myMap = scores(); let myMap2 = myMap.set('x', 100); The standard library Map is actually quite unique in the programming language world in that it is a module functor which you must use to construct a map

I'm currently learning OCaml, and I'm curious to HOW OCaml does its type inferencing. I know that it's done through a process called unification, and I tried reading about the algorithm in the published paper but the notation threw me off. Can anyone describe the step-by-step process for me? Actually, it can be argued that unification is an implementation detail of the algorithm. The type system is only a set of rules. The rules allow to check an existing typing derivation. The rules do not mention unification explicitly, although unification is a technique that naturally comes to mind when

It is possible to improve "raw" Fibonacci recursive procedure Fib[n_] := If[n < 2, n, Fib[n - 1] + Fib[n - 2]] with Fib[n_] := Fib[n] = If[n < 2, n, Fib[n - 1] + Fib[n - 2]] in Wolfram Mathematica. First version will suffer from exponential explosion while second one will not since Mathematica will see repeating function calls in expression and memoize (reuse) them. Is it possible to do the same in OCaml? How to improve let rec fib n = if n<2 then n else fib (n-1) + fib (n-2);; in the same manner? You pretty much do what the mathematica version does but manually: let rec fib = let cache =

Consider a recursive function, say the Euclid algorithm defined by: let rec gcd a b = let (q, r) = (a / b, a mod b) in if r = 0 then b else gcd b r (This is a simplified, very brittle definition.) How to memoize such a function? The classical approach of defining a high-order function memoize : ('a -> 'b) -> ('a -> 'b) adding memoization to the function is here useless, because it will only save time on the first call. I have found details on how to memoize such function in Lisp or Haskell: How do I memoize a recursive function in Lisp? Memoization with recursion These suggestions rely on the

So I have nice OCaml code (50000 lines). I want to port it to C. So Is there any free OCaml to C translator? This probably isn't what you want, but you can get the OCaml compiler to dump its runtime code in C: ocamlc -output-obj -o foo.c foo.ml What you get is basically a static dump of the bytecode. The result will look something like: #include <caml/mlvalues.h> CAMLextern void caml_startup_code( code_t code, asize_t code_size, char *data, asize_t data_size, char *section_table, asize_t section_table_size, char **argv); static int caml_code[] = { 0x00000054, 0x000003df, 0x00000029, 0x0000002a