The OCaml Language OCaml v. 3.12.0 — January 10, 2017 — OCamlPro SAS (http://www.ocamlpro.

com/)

Syntax Functions Conditionals

let f x = expr function with one arg Structural Physical
Implementations are in .ml files, interfaces are in .mli files. let rec f x = expr recursive function = == Polymorphic Equality
Comments can be nested, between delimiters (*...*) apply: f x <> != Polymorphic Inequality
Integers: 123, 1_000, 0x4533, 0o773, 0b1010101 let f x y = expr with two args Polymorphic Generic Comparison Function: compare
Chars: ’a’, ’\255’, ’\xFF’, ’\n’ Floats: 0.1, -1.234e-34 apply: f x y x<y x=y x>y
let f (x,y) = expr with a pair as arg compare x y -1 0 1
Data Types apply: f (x,y) Other Polymorphic Comparisons : >, >=, <, <=
unit Void, takes only one value: () List.iter (fun x -> e) l anonymous function
int Integer of either 31 or 63 bits, like 32 let f= function None -> act function definition Loops
int32 32 bits Integer, like 32l | Some x -> act by cases while cond do ... done;
int64 64 bits Integer, like 32L apply: f (Some x) for var = min_value to max_value do ... done;
float Double precision float, like 1.0 let f ~str ~len = expr with labeled args for var = max_value downto min_value do ... done;
bool Boolean, takes two values: true or false apply: f ~str:s ~len:10
char Simple ASCII characters, like ’A’ apply (for ~str:str): f ~str ~len Exceptions
string Strings of chars, like "Hello" let f ?len ~str = expr with optional arg (option) exception MyExn new exception
’a list Lists, like head :: tail or [1;2;3] let f ?(len=0) ~str = expr optional arg default exception MyExn of t * t’ same with arguments
’a array Arrays, like [|1;2;3|] apply (with omitted arg): f ~str:s exception MyFail = Failure rename exception with args
t1 * ... * tn Tuples, like (1,"foo", ’b’) apply (with commuting): f ~str:s ~len:12 raise MyExn raise an exception
apply (len: int option): f ?len ~str:s raise (MyExn (args)) raise with args
Constructed Types apply (explicitely ommited): f ?len:None ~str:s try expression with
let f (x : int) = expr arg has constrainted type |MyExn -> ... catch MyExn if raised in ex-
type record = new record type let f : ’a ’b. ’a*’b -> ’a function with constrainted pression
{ field1 : bool; immutable field = fun (x,y) -> x polymorphic type
mutable field2 : int; } mutable field Polymorphic variants
new variant type
Modules
type enum = type t = [ ‘A | ‘B of int ] closed variant
module M = struct .. end module definition
| Constant Constant constructor type u = [ ‘A | ‘C of float ]
module M: sig .. end= struct .. end module and signature
| Param of string Constructor with arg type v = [ t | u | ] union of variants
module M = Unix module renaming
| Pair of string * int Constructor with args let f : [< t ] -> int = function argument must be
include M include items from
| ‘A -> 0 | ‘B n -> n a subtype of t
module type Sg = sig .. end signature definition
Constructed Values module type Sg = module type of M signature of module
let f : [> t ] -> int = function t is a subtype
| ‘A -> 0 | ‘B n -> n | _ -> 1 of the argument
let r = { field1 = true; field2 = 3; } let module M = struct .. end in .. local module
let r’ = { r with field1 = false } let m = (module M : Sg) to 1st -class module
r.field2 <- r.field2 + 1; module M = (val m : Sg) from 1st -class module
let c = Constant module Make(S: Sg) = struct .. end functor
let c’ = Param "foo" module M = Make(M’) functor application
let c’’ = Pair ("bar",3) Module type items:
val, external, type, exception, module, open, include,
References, Strings and Arrays class

let x = ref 3 integer reference (mutable) Pattern-matching

x := 4 reference assignation match expr with
print_int !x; reference access | pattern -> action
s.[0] string char access | pattern when guard -> action conditional case
s.[0] <- ’a’ string char modification | _ -> action default case
t.(0) array element access | exception exn -> action try&match (≥4.02.0)
t.(0) <- x array element modification Patterns:
| Pair (x,y) -> variant pattern
Imports — Namespaces | { field = 3; _ } -> record pattern
| head :: tail -> list pattern
open Unix;; global open | [1;2;x] -> list-pattern
let open Unix in expr local open | (Some x) as y -> with extra binding
Unix.(expr ) local open | (1,x) | (x,0) -> or-pattern