ocaml SML and OCaml, Side by Side Disclaimer
This is dump/copy of Standard ML and Objective Caml, Side by Side jenso@csd.uu.se .
You may ask “Why making copy instead of simple references to the source? ” -
This page gives a quick side by side comparison of program fragments in the two ML dialects Standard ML (‘97 revision) and Objective Caml (version 3.12). It is primarily targetted at people who need to convert code between the two dialects. Where suitable we also mention common extensions to SML, or recent extensions of Ocaml. The comparison does not cover features that do not have an appropriate counter part in the sibling dialect (e.g. Ocaml’s object sublanguage, SML’s user-defined operator fixity, or advanced library issues).
Literals SML Ocaml - 3; # 3;; - 3.141; # 3.141;; - "Hello world"; # "Hello world";; - #"J"; # 'J';; - true; # true;; - (); # ();; - (3, true, "hi"); # (3, true, "hi");; - [1, 2, 3]; # [1; 2; 3];; - #[1, 2, 3]; Standard does not have vector literals but most implementations support them – use library functions otherwise Does not have vectors – use arrays Does not have array literals – use library functions # [|1; 2; 3|];;
Expressions SML Ocaml ~3*(1+7) div 2 mod 3 -3*(1+7)/2 mod 3 ~1.0/2.0 + 1.9*x -1.0 /. 2.0 +. 1.9 *. x a orelse b andalso c a || b && c or (deprecated) or b & c
Functions SML Ocaml fn f => fn x => fn y => f(x,y) fun f -> fun x -> fun y -> f (x,y) or fun f x y -> f (x,y) fn 0 => 0 | n => 1 function 0 -> 0 | n -> 1 f o g fun x -> f (g x) map SOME xs Does not have first-class constructors – use function instead, e.g. fun x -> Some x) xs # 2 triples # lab records Does not have first-class selectors – use function instead, e.g. fun (_ ,x,_ ) -> x) triples fun x -> x.lab) records f (inputLine stdIn) (inputLine stdIn) Evaluation order is undefined for application – use let let line1 = read_line () in let line2 = read_line () in
Control Flow SML Ocaml if 3 > 2 then "X" else "Y" if 3 > 2 then "X" else "Y" if 3 > 2 then print "hello" else () if 3 > 2 then print_string "hello" Note: expression has to have type unit while true do while true do done Does not have for while for i = 1 to 10 do done (print "Hello "; print_string "Hello "; or or begin end
Value Declarations SML Ocaml val name = expr let name = expr fun f x y = expr let f x y = expr val rec fib = fn n => if n < 2 then n else fib(n-1) + fib(n-2) or fun fib n = if n < 2 then n else fib(n-1) + fib(n-2) let rec fib = fun n -> if n < 2 then n else fib (n-1) + fib (n-2) or let rec fib n = if n < 2 then n else fib (n-1) + fib (n-2)
Type Declarations SML Ocaml type t = int -> bool type t = int -> bool type ('a,'b) assoc_list = ('a * 'b) list type ('a,'b) assoc_list = ('a * 'b) list datatype 'a option = NONE | SOME of 'a type 'a option = None | Some of 'a datatype t = A of int | B of u withtype u = t * t type t = A of int | B of u and u = t * t datatype v = datatype t type v = t = A of int | B of u datatype complex = C of real * real fun complex xy = C xy fun coord (C xy) = xy type complex = C of float * float let complex (x,y) = C (x,y) let coord (C (x,y)) = (x,y) or (note parentheses in type declaration) type complex = C of (float * float) let complex xy = C xy let coord (C xy) = xy
Matching SML Ocaml fun getOpt(NONE, d) = d | getOpt(SOME x, _ ) = x let get_opt = function -> d | (Some x, _ ) -> x fun getOpt (opt, d) = case opt of => d | SOME x => x let get_opt (opt, d) = match opt with -> d | Some x -> x fun take 0 xs = [] | take n nil = raise Empty | take n (x::xs) = x :: take (n-1) xs let rec take n xs = match n, xs with -> [] | n, [] -> failwith "take" | n, x::xs -> x :: take (n-1) xs Does not have guards – use if let rec fac = function -> 1 | n when n>0 -> n * fac (n-1) | _ -> raise Hell fun foo(p as (x,y)) = (x,p,y) let foo ((x,y) as p) = (x,p,y)
Tuples SML Ocaml type foo = int * float * string type foo = int * float * string val bar = (0, 3.14, "hi") let bar = 0, 3.14, "hi" or let bar = (0, 3.14, "hi") # 2 bar Does not have tuple selection – use pattern matching instead, e.g. let _ ,x,_ = bar in x # 2 Does not have first-class selectors – use function instead, e.g. function _ ,x,_ -> x or fun (_ ,x,_ ) -> x (inputLine stdIn, inputLine stdIn) Evaluation order is undefined for tuples – use let let line1 = read_line () in let line2 = read_line () in
Records SML Ocaml type foo = {x: int, y: float, s: string ref} Note: record types need not be declared type foo = {x: int; y: float; mutable s: string} Note: mutable field does not have the same type as a reference val bar = {x= 0, y= 3.14, s= ref ""} let bar = {x= 0; y= 3.14; s= ""} # x bar # y bar # s bar) bar. x . y . s # x Does not have first-class selectors – use function instead, e.g. fun r -> r. x val {x= x, y= y, s= s} = bar val {y= y, ...} = bar or val {x, y, s} = bar val {y, ...} = bar let {x= x; y= y; s= s} = bar let {y= y} = bar or (since Ocaml 3.12) let {x; y; s} = bar let {y; _} = bar {x = 1, y = # y bar, s = # s bar} {x = 1; y = bar. y; s = bar. s} or with x = 1} # s bar := "something" bar. s <- "something" Does not have polymorphic fields type bar = {f: 'a.'a -> int} {a = inputLine stdIn, b = inputLine stdIn} Evaluation order is undefined for records – use let let line1 = read_line () in let line2 = read_line () in = line1; b = line2}
References SML Ocaml val r = ref 0 let r = ref 0 !r !r or . contents r := 1 r := 1 or . contents <- 1 fun f(ref x) = x let f {contents= x} = x r1 = r2 r1 == r2
Comparisons SML Ocaml 2 = 2 2 = 2 val r = ref 2 let r = ref 2 (2, r) = (2, r) Does not have a proper generic equality (2, r) != (2, r) , on the other (2, r) = (2, ref 2) ) case String.compare(x,y) of => a => b => c match compare x y with when n < 0 -> a -> b _ -> c fun f x y = (x = y) val f : ''a -> ''a -> bool let f x y = (x = y) val f : 'a -> 'a -> bool Does not have equality type variables – comparison allowed on all types but may raise Invalid_argument exception eqtype t type t Does not have equality types – comparison allowed on all types but may raise Invalid_argument exception
Lists SML Ocaml [1, 2, 3] [1; 2; 3] [(1, 2), (3, 4)] [1, 2; 3, 4] List.length xs List.length xs List.map f xs List.map f xs List.app f xs List.iter f xs List.foldl op + 0 xs op - 100 xs List.fold_left (+) 0 xs List.all (fn x => x=0) xs fn x => x>0) xs List.for_all (fun x -> x=0) xs fun x -> x>0) xs val xys = ListPair.zip (xs, ys) let xys = List.combine xs ys val (xs, ys) = ListPair.unzip xys let (xs, ys) = List.split xys ListPair.app f (xs, ys) List.iter2 f xs ys [inputLine stdIn, inputLine stdIn] Evaluation order is undefined for lists – use let let line1 = read_line () in let line2 = read_line () in
Strings SML Ocaml "Hello " ^ "world\n" "Hello " ^ "world\n" Int.toString 13 string_of_int 13 String.size s String.length s String.substring(s, 1, 2) String.sub s 1 2 String.sub(s, 0) String.get s 0 or . [0] Strings are immutable, use CharArray for mutability String.set s 0 'F' or . [0] <- 'F'
Array Functions SML Ocaml Array.array(20, 1.0) Array.make 20 1.0 Array.fromList xs Array.from_list xs Array.tabulate(30, fn x => x*x) Array.init 30 (fun x -> x*x) Array.sub(a, 2) Array.get a 2 or Array.update(a, 2, x) Array.set a 2 x or . (2) <- x Array.copy{src= a, si= 10, dst= b, di= 0, len= 20} Array.blit ~ src: a ~ src_pos: 10 ~ dst: b ~ dst_pos: 0 ~ len: 20
SML Ocaml fun copyFile(name1, name2) = let val file1 = TextIO.openIn name1 val s = TextIO.inputAll file1 val _ = TextIO.closeIn file1 val file2 = TextIO.openOut name2 in end let copy_file name1 name2 = let file1 = open_in name1 in let size = in_channel_length file1 in let buf = String.create size in let file2 = open_out name2 in Caveat: above code actually contains a race condition.
Exceptions SML Ocaml exception Hell exception Hell exception TotalFailure of string exception Total_failure of string raise TotalFailure "Unknown code" raise (Total_failure "Unknown code") expr handle TotalFailure s => try expr with -> ouch ()
Local Declarations SML Ocaml fun pyt(x,y) = let val xx = x * x val yy = y * y in end let pyt x y = let xx = x *. x in let yy = y *. y in local fun sqr x = x * x in fun pyt(x,y) = Math.sqrt(sqr x + sqr y) end Does not have local let let structure X = F(A) in end Standard does not have structure declarations in let let module X = F (A) in Experimental language extension let open M in expr end let open M in expr Note: since Ocaml 3.12 let datatype t = A | B exception E in end Does not have local type or exception declarations – use global declarations or let module
Structures SML Ocaml structure X :> S = struct type t = int val x = 0 end module X : S = struct type t = int let x = 0 end X :> S (X : S) X : S Does not have transparent signature ascription – use opaque ascription and with open X include X local open X in end open X
Functors SML Ocaml functor F(X : S) = struct end module F (X : S) = struct end or module F = functor (X : S) -> struct end functor F(X : sig type t end ) = body structure X = F (struct type t = int end ) or functor F(type t) = body structure X = F(type t = int) module F (X : sig type t end ) = body module X = F(struct type t = int end ) functor F (X : S) (Y : T) = body Standard does not have higher-order functors but several implementations support them module F (X : S) (Y : T) = body or module F = functor (X : S) -> functor (Y : T) -> body functor F(X : S) = let structure Y = G(X) in end Does not have let
Signatures SML Ocaml signature S = sig type t eqtype u val x : t structure M : T end module type S = sig type t type u val x : t module M : T end functor F(X : S) : S Standard does not have higher-order functors but several implementations support them module F (X : S) : S or module F : functor (X : S) -> S include S include S Does not have open open X structure X : A structure Y : B sharing type X.t = Y.u Does not have sharing with S where type t = int S with type t = int S where X = A.B Standard does not have where where type S with X = A.B signature S = sig signature A signature B = A end Standard does not have nested signatures but some implementations support them module type S = sig module type A module type B = A end