Operators in OCaml

Operators are the building blocks of expressions. In OCaml they have characteristics that surprise newcomers from C-family languages: arithmetic operators are not overloaded between integers and floats, and several functional operators like |> and @@ shape how idiomatic OCaml is written.

Because OCaml is a statically-typed language with type inference, the compiler uses operators as strong type hints. Writing 1 + 2.0 is a compile-time error — you must use +. for floats. This rigidity is intentional: it eliminates a whole class of numeric bugs and keeps type inference predictable.

In this tutorial you will learn the full set of arithmetic, comparison, logical, string, functional, and reference operators that OCaml provides, along with how operator precedence works.

Arithmetic Operators

OCaml separates integer and floating-point arithmetic into two distinct sets of operators. The “dotted” forms (+., -., *., /., **) work on floats; the plain forms work on integers.

Create a file named operators.ml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

(* Operators in OCaml - comprehensive demo *)

(* ===== Integer Arithmetic ===== *)
let a = 17
let b = 5

let () =
  print_endline "=== Integer Arithmetic ===";
  Printf.printf "a = %d, b = %d\n" a b;
  Printf.printf "a + b   = %d\n" (a + b);
  Printf.printf "a - b   = %d\n" (a - b);
  Printf.printf "a * b   = %d\n" (a * b);
  Printf.printf "a / b   = %d  (integer division truncates)\n" (a / b);
  Printf.printf "a mod b = %d\n" (a mod b);
  Printf.printf "-a      = %d  (unary negation)\n" (-a)

(* ===== Float Arithmetic (note the dots) ===== *)
let x = 17.0
let y = 5.0

let () =
  print_endline "\n=== Float Arithmetic ===";
  Printf.printf "x +. y = %.2f\n" (x +. y);
  Printf.printf "x -. y = %.2f\n" (x -. y);
  Printf.printf "x *. y = %.2f\n" (x *. y);
  Printf.printf "x /. y = %.2f\n" (x /. y);
  Printf.printf "x ** y = %.2f  (power, float only)\n" (x ** y);
  Printf.printf "sqrt 16.0 = %.2f\n" (sqrt 16.0)

(* ===== Comparison Operators ===== *)
let () =
  print_endline "\n=== Comparison Operators ===";
  Printf.printf "5 = 5    -> %b  (structural equality)\n" (5 = 5);
  Printf.printf "5 <> 6   -> %b  (structural inequality)\n" (5 <> 6);
  Printf.printf "5 < 6    -> %b\n" (5 < 6);
  Printf.printf "5 > 6    -> %b\n" (5 > 6);
  Printf.printf "5 <= 5   -> %b\n" (5 <= 5);
  Printf.printf "5 >= 6   -> %b\n" (5 >= 6)

(* ===== Logical Operators ===== *)
let () =
  print_endline "\n=== Logical Operators ===";
  Printf.printf "true && false -> %b\n" (true && false);
  Printf.printf "true || false -> %b\n" (true || false);
  Printf.printf "not true      -> %b\n" (not true);
  Printf.printf "(2 > 1) && (3 < 4) -> %b\n" ((2 > 1) && (3 < 4))

(* ===== String Concatenation ===== *)
let () =
  print_endline "\n=== String Concatenation ===";
  let greeting = "Hello" ^ ", " ^ "OCaml" ^ "!" in
  print_endline greeting

(* ===== Functional Operators ===== *)
let () =
  print_endline "\n=== Functional Operators ===";
  let double n = n * 2 in
  let add_one n = n + 1 in
  (* Pipe operator: x |> f  is the same as  f x *)
  let piped = 5 |> double |> add_one in
  Printf.printf "5 |> double |> add_one     = %d\n" piped;
  (* Application operator: f @@ x  is the same as  f x  (right-assoc, low precedence) *)
  let applied = add_one @@ double @@ 5 in
  Printf.printf "add_one @@ double @@ 5     = %d\n" applied

(* ===== Reference Operators ===== *)
let () =
  print_endline "\n=== Reference Operators ===";
  let counter = ref 0 in
  counter := !counter + 10;   (* := assigns, ! dereferences *)
  counter := !counter + 5;
  Printf.printf "counter after +10, +5 = %d\n" !counter

(* ===== Operator Precedence ===== *)
let () =
  print_endline "\n=== Precedence ===";
  Printf.printf "2 + 3 * 4    = %d  (* binds tighter than +)\n" (2 + 3 * 4);
  Printf.printf "(2 + 3) * 4  = %d  (parentheses override)\n" ((2 + 3) * 4);
  Printf.printf "10 - 4 - 2   = %d  (- is left-associative)\n" (10 - 4 - 2)

Why two sets of arithmetic operators?

In a language with type inference, overloading + for both int and float would force the compiler to either pick a default (surprising) or demand annotations everywhere (verbose). By giving floats their own operators, OCaml keeps inference predictable and makes the type of every numeric expression visually obvious. The ** operator is an exception — it only exists for floats, since integer exponentiation is rarely what you want.

Structural vs Physical Equality

OCaml has two equality operators with very different meanings:

• = — structural equality (compares contents, like Java’s .equals)
• == — physical equality (compares references, like Java’s ==)

For everyday code you almost always want =. The same applies to <> (structural) versus != (physical).

The Pipe Operator |>

The pipe operator is one of OCaml’s most beloved features. It flips function application so data flows left-to-right, much like Unix pipes:

1
2
3
4
5
6
7
8

(* Without |>  -  reads inside-out *)
let result = List.length (List.filter (fun x -> x > 0) [1; -2; 3; -4; 5])

(* With |>  -  reads top-to-bottom *)
let result =
  [1; -2; 3; -4; 5]
  |> List.filter (fun x -> x > 0)
  |> List.length

Both expressions produce 3, but the piped version reads in the order the operations happen.

Running with Docker

1
2
3
4
5

# Pull the official OCaml image
docker pull ocaml/opam:alpine

# Run the operators example
docker run --rm -v $(pwd):/home/opam/app -w /home/opam/app ocaml/opam:alpine ocaml operators.ml

If you prefer compiled output for speed:

1
2

# Native compilation
docker run --rm -v $(pwd):/home/opam/app -w /home/opam/app ocaml/opam:alpine sh -c 'ocamlopt operators.ml -o operators && ./operators'

Expected Output

=== Integer Arithmetic ===
a = 17, b = 5
a + b   = 22
a - b   = 12
a * b   = 85
a / b   = 3  (integer division truncates)
a mod b = 2
-a      = -17  (unary negation)

=== Float Arithmetic ===
x +. y = 22.00
x -. y = 12.00
x *. y = 85.00
x /. y = 3.40
x ** y = 1419857.00  (power, float only)
sqrt 16.0 = 4.00

=== Comparison Operators ===
5 = 5    -> true  (structural equality)
5 <> 6   -> true  (structural inequality)
5 < 6    -> true
5 > 6    -> false
5 <= 5   -> true
5 >= 6   -> false

=== Logical Operators ===
true && false -> false
true || false -> true
not true      -> false
(2 > 1) && (3 < 4) -> true

=== String Concatenation ===
Hello, OCaml!

=== Functional Operators ===
5 |> double |> add_one     = 11
add_one @@ double @@ 5     = 11

=== Reference Operators ===
counter after +10, +5 = 15

=== Precedence ===
2 + 3 * 4    = 14  (* binds tighter than +)
(2 + 3) * 4  = 20  (parentheses override)
10 - 4 - 2   = 4  (- is left-associative)

Defining Your Own Operators

OCaml lets you define infix operators. An operator’s first character determines its precedence — for example, an operator starting with * binds tighter than one starting with +.

Create a file named custom_ops.ml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

(* Custom function composition operator *)
let (>>) f g x = g (f x)

let double x = x * 2
let add_one x = x + 1

(* double then add_one *)
let f = double >> add_one

let () =
  Printf.printf "(double >> add_one) 5 = %d\n" (f 5);
  Printf.printf "(double >> add_one) 10 = %d\n" (f 10)

Run it:

1

docker run --rm -v $(pwd):/home/opam/app -w /home/opam/app ocaml/opam:alpine ocaml custom_ops.ml

Expected output:

(double >> add_one) 5 = 11
(double >> add_one) 10 = 21

This >> operator does forward composition: (f >> g) x evaluates to g (f x). It is a common idiom in functional OCaml code, though it isn’t part of the standard library — you define it where you need it.

Key Concepts

• Integer and float arithmetic are separate: use + - * / for integers and +. -. *. /. for floats. Mixing them is a type error.
• ** is the float power operator — there’s no built-in integer exponentiation.
• = is structural equality, == is physical (reference) equality. Use = and <> in almost all cases.
• && and || short-circuit like in most languages; not is the boolean negation function.
• ^ concatenates strings; it is not addition. Lists use @ for concatenation and :: to prepend.
• |> (pipe) and @@ (application) rewrite function application for readability. x |> f equals f x; f @@ x also equals f x but is right-associative with low precedence so it removes parentheses.
• References use ref, :=, and !: create with ref value, assign with :=, dereference with the prefix !.
• You can define your own infix operators; their first character determines their precedence class.