ocaml

Is there a good way to get the line number of exception in OCaml without debugging symbols? Certainly, if we turn on debugging symbols and run with OCAMLRUNPARAM=b , we can get the backtrace. However, I don't really need the whole backtrace and I'd like a solution without debugging symbols. At the moment, we can write code like try assert false with x -> failwith (Printexc.to_string x ^ "\nMore useful message") in order to get the file and line number from assert, but this seems awkward. Is there a better way to get the file and line number of the exception? There are global symbols __FILE__

How can I write a function in OCaml in which one or more argument are optional? let foo x y z = if(x+y > z) then true else false;; If foo do not receive the z argument it uses 0 as z . foo 3 3 2 -> true foo 3 3 10 -> false foo 2 1 -> true Is there any OCaml feature to achieve this? OCaml doesn't have optional arguments like you'd find in Java or C#. Since functions can be partially applied, optional arguments can make it hard to tell when you're done passing arguments and would like the function to be evaluated. However, OCaml does have labeled arguments with default values , which can be used

I'm looking for a proper name for a data type that combines ADT with explicit subtyping. In one of my applications, I use a structure similar to ADT to represent parse trees, on which I perform recursive pattern matching. I find it rather convenient if I could combine ADT with subtyping, as demonstrated in the example below: Note: the example is written in Haskell's syntax, but this is not Haskell code. data Empty = Empty data Expr = Int Int | Add Expr AddOp Expr data OptionalExpr = | Empty // I want to make Empty a subtype of OptionalExpr | Expr // I want to make Expr a subtype of

So far, giving Google search strings such as "ocaml" regex "ocaml" hashtbl etc. has usually gotten me the documentation I've been looking for. One notable exception has been "ocaml" "String.Map" With this search, all I can find (documentation-wise, that is), is documentation for the String.map function of the String module (or is it "package"?). (If understand correctly, String.Map is a data structure, namely a map whose keys have type string , rather than a function.) Even more forceful Google search specs like "ocaml" intitle:"String.Map" ...failed to find the documentation I'm after. Is

I need to use hashtable of mutable variable in Ocaml, but it doesn't work out. let link = Hashtbl.create 3;; let a = ref [1;2];; let b = ref [3;4];; Hashtbl.add link a b;; # Hashtbl.mem link a;; - : bool = true # a := 5::!a;; - : unit = () # Hashtbl.mem link a;; - : bool = false Is there any way to make it works? Mutable variables that may happen to have the same content can still be distinguished because they are stored at different locations in memory. They can be compared with the physical equality operator ( == ). However, OCaml doesn't provide anything better than equality, it doesn't

In solving projecteuler.net's problem #31 [ SPOILERS AHEAD ] (counting the number of ways to make 2£ with the British coins), I wanted to use dynamic programming. I started with OCaml, and wrote the short and very efficient following programming: open Num let make_dyn_table amount coins = let t = Array.make_matrix (Array.length coins) (amount+1) (Int 1) in for i = 1 to (Array.length t) - 1 do for j = 0 to amount do if j < coins.(i) then t.(i).(j) <- t.(i-1).(j) else t.(i).(j) <- t.(i-1).(j) +/ t.(i).(j - coins.(i)) done done; t let _ = let t = make_dyn_table 200 [|1;2;5;10;20;50;100;200|] in

According to this previous answer You could implement List.map like this: let rec map project = function | [] -> [] | head :: tail -> project head :: map project tail ;; but instead, it is implemented like this: let rec map project = function | [] -> [] | head :: tail -> let result = project head in result :: map project tail ;; They say that it is done this way to make sure the projection function is called in the expected order in case it has side effects, e.g. map print_int [1;2;3] ;; should print 123 , but the first implementation would print 321 . However, when I test both of them myself