Caml quick reference guide

(* This is a comment in Caml *)

Constants

Example

Float: 1.0 +. 2.0 *. 3.0 -. 1.0 = 6.0
Operations: sin, cos, exp, sqrt, atan, atan2
float_of_string, string_of_float, float_of_int

Example

Strings: "Hello\n"
Operations: Concatenation ^, make_string, string_length, sub_string, s.[0], s.[0] <- `a`

Example

Characters: `a`
Operations: int_of_char, char_of_int

Booleans: true, false
Operations: &&, ||, not

Example

Nothing: type unit, value (), argument or result with no particular meaning.

Example

Using parentheses

In Caml, parens are significant and use the mathematical rules of trigonometric functions.

In Caml, 1 + 2 * x means 1 + (2 * x)
as in math.

In Caml, f x means f (x)
as in math sin x means sin (x).

In Caml, f x + g x means (f x) + (g x)
as in math sin x + cos x means (sin x) + (cos x).
Hence, f x - y means (f x) - y
as in math sin x - 1 means (sin x) - 1.

In Caml, this rule is generalized to any infix operator:
f x :: g x means (f x) :: (g x).

Defining Values

Defining Functions

Special cases: a procedure is a function with no mathematically sound result, it returns ().
For instance, assignment functions return ().

Calling Functions

Special cases: functions with no argument get () as argument.
For instance print_newline is called with print_newline ().

Matching

A pattern matching is a list of clauses pattern -> expression: each clause is tried in the order of presentation; the first clause for which the pattern corresponds to (is more general than) the value is selected; the corresponding expression is then returned.

There are constant patterns, variable patterns or compound patterns.

 | constant_pattern -> expression
 | variable_pattern -> expression
 | compound_pattern -> expression;;

 let rec fact = function
 | 0 -> 1
 | n -> n * fact (n - 1);;

Variable pattern: identifiers or the character _
For instance

 let rec fib = function
 | 0 -> 1
 | 1 -> 1
 | n -> fib (n - 1) + fib (n - 2);;

Compound pattern: a constructor applied to a pattern Constructor pattern, lists x :: l, tuples (pattern1, pattern2), records {label1=pattern1; ...; labeln=patternn}.

Complex patterns:

• tuple pattern: | (pattern, pattern) -> expression
• alias pattern: | pattern as ident -> expression
• or pattern: | constant_pattern | constant_pattern -> expression
• range pattern: | character pattern .. character pattern -> expression
  Example:

   let letter = function
   | `a` .. `z` | `A` .. `Z` -> true
   | _ -> false;;
  

• Clause with guard: | pattern when condition -> expression
  Example:

   let letter = function
   | c when c >= `a` && c <= `z`
         || c >= `A` && c <= `Z` -> true
   | _ -> false;;
  

Explicit call to the pattern matching

For instance:

 match f 2 with
 | 1 -> expression
 | n -> expression

Anonymous function

With pattern matching on this argument:

 function
 | pattern -> expression
 | ...
 | pattern -> expression

References

Access: operator ! (! reference)

Assignment: operator := (reference := value)
For instance: x := !x + 1

Vectors

Lists

 match l with
 | [] -> ...
 | x :: l -> ...

Loops

Sequence

Conditional

Standard comparison operators: <, >, <=, >=, <>
Physical equality: ==, !=

Exceptions

Input-output

• Screen:
  Printing: print_string, print_int, print_float, ..., or encore printf "%d\n" 1
• Keyboard: read_line
• Files:
  • for reading: open_in, close_in, input_line, input_string, input_char
  • for writing: open_out, close_out, output_string, output_char (structured data: input_value, output_value)

Defining Types

 type name =
 | Constant_constructor
 | Constructor_with_argument of expression_de_type;;

Record type:

 type name = {label1 : type_of_the_field; label2 :
type_of_the_field};;

Type abbreviation:

 type name == type_expression;;

Defining exceptions