You intrigued me with this Ocaml, so I learned some basics fastly and yes it’s got really good type inferring mechanism, but… as always there are some but’s.
For Ocaml compiler code below is good, with fantastic types int, as just for programmer who wrote this code fastly. But this code got serious bug. Can you see it at first look?
Side note: Used Fibonacci to simplify example as much as possible.
let rec do_fib = function
| 0, prev, cur -> prev
| n, prev, cur -> do_fib(n - 1, cur, prev + cur);;
(* val do_fib : int * int * int -> int = <fun> *)
let fib n = do_fib(n, 0, 1);;
(* val fib : int -> int = <fun> *)
So the bug is:
fib(0);;
(* - : int = 0 *)
fib(1);;
(* - : int = 1 *)
fib(-1);;
(* BANG: forever and ever :) *)
So relaying only on inferring types can be sometimes really deceiving.
With implicit type annotation or definition you have more chance to not introduce this bug at all or if you introduce it more chance to find this bug just by reading code before running this code with bad value at runtime.
@spec fib(non_neg_integer()) :: non_neg_integer()
def fib(n), do: fib(n, 0, 1) #omg, where is guard for n >= 0?
def fib(0, prev, _), do: prev
def fib(n, prev, cur), do: fib(n - 1, cur, prev + cur)
