Forem: david2am

OCaml in 5 Minutes: From Zero to 'Hello'

david2am — Fri, 14 Nov 2025 16:32:34 +0000

Tired of the OCaml setup rabbit hole?

In 5 minutes, you’ll have a fully working OCaml project.

Just copy, paste, run.

Index

Global Setup
- Install OCaml
- Install Platform Tools
Create a New Project
- Create a new project
- Create a Switch
- Configure Git
- Run the Project

Next Steps
References

🟣 Global Setup

Install OCaml

Start by installing Opam, the OCaml package manager, which is similar to npm in JavaScript. It manages packages and compiler versions.

For macOS

brew install opam

For Linux

sudo apt-get install opam

Initialize OCaml's global configuration:

opam init -y

Load Opam's Environment:

eval $(opam env)

Consider adding eval $(opam env) command to your .bashrc or .zshrc file to automate this process.

Install Platform Tools

Install tools to assist you:

opam install ocaml-lsp-server odoc ocamlformat utop

ocaml-lsp-server: editor integrations (VS Code, Neovim, etc.)

odoc: documentation generator

ocamlformat: automatic code formatter

utop: improved OCaml REPL

🟣 Create a New Project

Dune is OCaml's default build system, it helps you create and manage projects.

Create a new project

Dune is already installed by the platform tools so just run:

dune init proj my_project
cd my_project

Your project structure will look like this:

my_project/
├── lib/
│   └── dune
├── bin/
│   ├── main.ml
│   └── dune
├── test/
│   └── test_my_project.ml
├── dune-project
└── my_project.opam

lib/: contains your modules (.ml files).

bin/: contains your main.ml alias your runnable app file.

test/: contains your tests.

dune-project: it's the equivalent to package.json in JavaScript or requirements.txt in Python.

bin/main.ml: the application’s entry point.

Most of your work will happen in the lib/ folder, and the main.ml file.

Create a Switch

Switches in OCaml are similar to Python's virtual environments. They isolate compilers and package versions from other projects or global configurations.

Create a switch with a compiler version (5.3.0 in this example):

opam switch create . 5.3.0 --deps-only

This command creates and stores switch artifacts in the _opam/ folder. The --deps-only flag ensures that only dependencies are installed, and not the current project been taken as another dependency.

If you want to know the available compiler versions run this command and pick one:
opam switch list-available

Activate the Switch

Run at your project directory:

eval $(opam env)

Install Dev Tools for the Switch

Run:

opam install ocaml-lsp-server odoc ocamlformat

Enable Automatic Switch Detection

You only need to run this command once, it enables automatic switch detection when moving from one OCaml project to another:
opam init --enable-shell-hook

Configure Git

Dune projects do not include a .gitignore file by default. Create it manually:

# .gitignore
_opam/
_build/

Initialize Git

Run:

git init

Run the Project

Compile and execute your project:

dune build
dune exec my_project

Alternatively, use watch mode to accomplish both commands in one:

dune exec -w my_project

And voilà you will see this hello world message in your terminal:

Hello, World!

If you wonder where this code lives go to the lib/ folder and open the main.ml file and you will see it:

(* lib/mail.ml *)
let () = print_endline "Hello, World!"

Congratulations! You have created your first OCaml/Dune project!

Happy coding with OCaml! 🚀

Next Steps

Did this help?

Give it a ❤️
Follow for Part 2: OCaml Modules and Libraries
If you want to dig into OCaml I wrote Basic OCaml and its second part Practical OCaml
Share with one friend learning systems programming

Have a question? Comment below — I reply to all!

References

OCaml Modules & Libraries (Like JS but Better)

david2am — Fri, 14 Nov 2025 16:25:55 +0000

Tired of the OCaml setup rabbit hole?

In 5 minutes, you’ll build your first OCaml program.

Just copy, paste, run.

Index

Use Modules and Libraries
- Create a Module
- Create a dune File
- Register a Library
- Use a Library
Create an Interface File

Next Steps

🟣 Use Modules and Libraries

Let's add some modules, interface files, tests, and more!

Create a Module

In OCaml the concept of module is similar to the one in Python or JavaScript where every file is considered an independent unit of work with its own namespace.

Create a calc.ml file in the lib/ folder and add the following functions:

(* lib/calc.ml *)
let add x y = x + y

let sub x y = x - y

Create a dune File

In Dune it's not enough to create a file to use it as a module, you need to explicitly say it through adding metadata in a dune file.

But before setting the metadata it's important to differentiate between a module and a library in OCaml:

Module = single unit of code organization. They form what it's called a compilation unit, a fully independent program from the compiler's perspective
Library = packaged collection of modules for distribution

In this occasion you will define everything inside the lib/ folder as a library named math so you could later call the Calc module through it.

Create a dune file in lib/:

; lib/dune
(library
 (name math))

Libraries in OCaml are similar to index files in JavaScript; they expose modules.

Register a Library

In a similar way, if you want to consume a library in another .ml file you need to register it in its adjacent dune file to make it accessible, let's make it accessible to the bin/main.ml file:

In the bin/ folder open the dune file and register the library by its name:

; bin/dune
(executable
 (public_name ocaml_dune)
 (name main)
 (libraries math)) ; Include your module here

Use a Library

Use the open keyword to access the library in main.ml:

(* bin/main.ml *)
open Math

let () = (* in other programming languages this would be to your main function equivalent *)
  let result = Calc.add 2 3 in
  print_endline (Int.to_string result); (* Output: 5 *)

Notice that you also use the Int module from the standard library to convert a number to a string.

Run the Project

Compile and execute your project in watch mode:

dune exec -w my_project

🟣 Create an Interface File

In Dune it's possible to separate your interfaces from your implementation through .mli files. They serve as a way for:

Encapsulation: helps define the public interface of a module.
Hide implementation details: makes possible to change module internals without affecting other dependent parts.
Documentation: it's a good practice to include specifications for clarity.

In the lib/ folder create an .mli file with the same name as its corresponding module, calc.mli in this case:

(* lib/calc.mli *)
val add : int -> int -> int
(** [add x y] returns the sum of x and y. *)

Run the Project

Run:

dune exec -w my_project

Add the `sub` function to the `main.ml` file

(* bin/main.ml *)
open Math

let () = (* in other programming languages this would be to your main function equivalent *)
  let result = Calc.add 2 3 in
  print_endline (Int.to_string result); (* Output: 5 *)

  let result = Calc.sub 3 1 in
  print_endline (Int.to_string result) (* Output: 2 *)

As you see if you attempt to use sub it will result in an error, it's because the sub function has not been exposed yet, to solve it add the sub interface in calc.mli:

(* lib/calc.mli *)
val add : int -> int -> int
(** [add x y] returns the sum of x and y. *)

val sub : int -> int -> int
(** [sub x y] returns the difference of x and y. *)

Congratulations! You have created your first code in OCaml!

Happy coding with OCaml! 🚀

Next Steps

Did this help?

Give it a ❤️
Follow for Part 3: OCaml Dependencies
If you want to dig into OCaml I wrote Basic OCaml and its second part Practical OCaml
Share with one friend learning systems programming

Have a question? Comment below — I reply to all!

References

Why you should consider OCaml in your toolkit

david2am — Fri, 13 Jun 2025 15:43:03 +0000

david2am

Jun 13 '25

When Failure is Not an Option: A Practical Case for OCaml

#ocaml #performance #functional #programming

Comments

6 min read

When Failure is Not an Option: A Practical Case for OCaml

david2am — Fri, 13 Jun 2025 15:29:28 +0000

Sources

Index

A New Perspective on Programming
The "Aha!" Moment
The Five Pillars of OCaml
- Performance Without Sacrifice
- Correctness with Safety Nets
- Power and Agility
- Functional
- But Practical
The Takeaway
Explore Together
Next Steps

🟣 A New Perspective on Programming

Don't take me wrong, we do great things on the Web, and there are a lot of smart people working on it but I started to feel that I needed more within programming from a year ago.

Curiosity lead me to system's level programming languages, I learned some C and C++ in the university, but I wanted something less intimidating than C or Rust and more performant than JavaScript or Python, in other words, something in between.

So I learn a bit of Zig (in my opinion a wonderful programming language), I enjoyed it but I felt the trade-off between fine-grained control and rapid productivity, so... I needed something else.

🟣 The Aha Moment

I used to hear Developer Voices, a YouTube channel directed by Kris Jenkins, and one day I heard a conversation between Kris and a guy, Leandro Ostera, about this programming language called OCaml 🐪, to be honest I didn't get much, I just heard about functional programming here an there and this catchy phrase "OCaml my Caml!" that I didn't get 😆 but by listening Leandro I realized that he also experienced this "should be more out there" sensation, so I felt connected, and to my surprise the programming language he talked seems to be in the sweet spot I was looking for: something performant and expressive without much sacrifices.

So I used my spare time to learn about OCaml, tried it a little bit and after some time I'm still in love and I want to share with you some of the reasons I think it's especial:

It's elegant and effective in the real world.
It has a friendly community of very talented people.
There are some companies that express such confidence in the language that built their entire organizations in OCaml's shoulders.

🟣 The Five Pillars of OCaml

You might be thinking, "I can do all of this in my current language." And you're probably right. But let me ask you: how confident are you in the code you just wrote? Would you bet your company's critical system on it?

At least in the TypeScript world, we often add state machine libraries to gain a high degree of confidence and predictability, but that means extra dependencies, complexity, and more things that could break.

With OCaml, that confidence comes built-in, the language itself is your safety net:

Performance: It offers native compilation and static typing without sacrificing expressiveness.
Correctness: It helps you deliver what you intended with safety and reliability baked in.
Dexterity: It gives you the power and agility to get things done quickly, efficiently, and safely.
Functional It's easy to reason about.
Practical Where purity could introduce complexity OCaml introduce simplicity.

Let's see how this works in practice.

🟣 Performance Without Sacrifice

OCaml is a compiled, statically-typed language that offers a rare combination of high-level expressiveness and raw performance.

Its native code compiler produces fast, optimized executables.
It provides zero-cost abstractions, so you can write elegant and declarative code without a performance penalty.
Its predictable garbage collector is ideal for low-latency systems.

In other words, OCaml let you focus on your business logic without a performance penalty.

🟣 Correctness with Safety Nets

Thinking in Edge Cases

I mentioned before that as web developers we gain confidence using state machine libraries, OCaml in another hand, give you the same with two built-in features: types and pattern-matching.

For example: OCaml's compiler forces you to consider edge cases from the beginning:

let my_favorite_language (my_favorite :: the_rest) = my_favorite;;
(* Warning 8 [partial-match]: this pattern-matching is not exhaustive.
Here is an example of a case that is not matched:
[] *)

You're encouraged to handle all possibilities using pattern matching, a powerful feature that's like a switch statement on steroids.

let my_favorite_language languages =
  match languages with
  | first :: the_rest -> first
  | [] -> "OCaml" (* A sensible default! *)

Making Illegal States Unrepresentable

This is OCaml's superpower. Imagine you have a shape type:

type shape =
  | Circle of float
  | Rectangle of float * float

When business requirements change and you need to add a Triangle, you simply update the type:

type shape =
  | Circle of float
  | Rectangle of float * float
  | Triangle of float * float  (* base, height *)

The compiler then becomes your assistant, pointing out every function that doesn't yet handle Triangle.

let area shape =
  match shape with
  | Circle radius -> Float.pi *. radius ** 2.
  | Rectangle (width, height) -> width *. height

(*
  Error (warning 8): this pattern-matching is not exhaustive.
  Here is an example of a case that is not matched:
  Triangle (_, _)
 *)

Now your business logic is encoded directly in the type system. Once you fix the compiler errors, you can be confident that the code is correct.

🟣 Power and Agility

Type Inference That Helps, Not Hinders

OCaml provides strong typing without the verbose annotations. Its powerful type inference system deduces types for you, letting you focus once again in your domain.

let sum x y = x + y;;
(* val sum : int -> int -> int = <fun> *)

When you make a mistake, the error messages are your friend.

let add_potato x = x + "potato"
(* Error: This expression has type string but an expression was expected of type int *)

You get the benefits of strong typing with the feel of a dynamic language, giving you the agility to refactor and build with confidence.

🟣 Functional

It's very easy to reason about an OCaml program:

Everything is an Expression

In OCaml, almost everything is an expression that returns a value. This includes not just calculations but even conditionals.

(* Definitions are like permanent assignments *)
let num = 3
let sum x y = x + y

(* Even conditionals are expressions that return a value *)
let result = if condition then "this value" else "that value"

Functional to the Core

OCaml encourages a functional style, which leads to more predictable and maintainable code.

Immutability by Default: Once a value is defined, it can't be changed. This eliminates a whole class of bugs related to unexpected state changes.

let pi = 3.1     (* pi is now 3.1 *)
(* pi = 3.1415  <- This would be an error *)
let pi = 3.1415  (* This creates a *new* value for pi *)

Higher-Order Functions: Functions are treated like any other value. You can pass them as arguments, return them from other functions, and store them in data structures.
```
(* 'List.fold_left' takes a function as its first argument *)
let sum lst =
  List.fold_left (fun acc el -> acc + el) 0 lst
```
Purity: A pure function's behavior depends only on its inputs. This makes functions easier to reason about, compose, and test because there are no hidden side effects.

🟣 But Practical

While OCaml encourages purity, it's also pragmatic. In situations where controlled mutation can simplify code, OCaml provides a clear and expressive way to handle it, for example allowing to access a reference outside it's normal scope:

let next =
  let counter = ref 0 in
  fun () ->
    incr counter;
    !counter

🟣 The Takeaway

OCaml is, in my opinion, the only language that strikes the right balance between performance, expressiveness, and practicality.

OCaml's sweet spot is high-predictability, high-reliability, and high-performance systems. This is why it's trusted in production by companies in demanding fields:

Finance: Jane Street
Developer Tools: Docker
Web Services: Ahrefs
Blockchain: Tezos

The pattern is clear: when failure is not an option, OCaml becomes the option.

But here's the key insight: because OCaml doesn't force you to trade expressiveness for performance, its potential extends far beyond these critical systems. We could—and should—be building much more with it.

🟣 Explore Together

If any of this sparked your curiosity, I'd love to explore it with you. I'm building small things, writing about my journey, and learning in public.

Let's stay in touch. Let's keep growing.

🟣 Next Steps

If you want to explore and build your first OCaml project visit my tutorial OCaml/Dune
If you want to explore OCaml syntax visit my tutorial Basic OCaml

Practical OCaml

david2am — Fri, 25 Apr 2025 21:17:50 +0000

Welcome to the second part of Basic OCaml, where we dive into writing practical OCaml code! This tutorial builds upon the foundational concepts introduced earlier, ensuring a smooth and comprehensive learning experience. Each topic is presented in an easy-to-follow manner, with new concepts building upon previous ones.

This tutorial is based on my notes from Professor Michael Ryan Clarkson’s excellent course, along with insights from OCaml’s official manual and documentation. A huge thank you to Professor Michael for his incredible teaching and to Sabine for creating such clear and comprehensive documentation! 🫰

References

Happy reading! 🚀

Index

Tail Recursion Optimization
Recursive and Parameterized Variants
Handling Errors
- Option Type
- Result Type
- Exceptions
Mutations in OCaml
- References (Refs)
- Aliasing
- Equality
- Sequence Operator (;)
- Mutable Record Fields
Arrays

Tail Recursion Optimization

Tail Recursion is an optimization technique where a function call is the last action in a function. This allows the compiler to reuse the current function's stack frame for the next function call, preventing stack overflow and improving performance.

Steps to Apply Tail Recursion:

Identify the Base Case and Recursive Case: Determine the condition under which the recursion should stop (base case) and the part of the function that makes the recursive call (recursive case).
Introduce an Accumulator: Add an additional parameter to the function, known as an accumulator, which will store the intermediate results of the computation.
Modify the Recursive Call: Change the recursive call so that it passes the accumulator as an argument, and ensure that the recursive call is the last operation in the function.
Update the Base Case: Modify the base case to return the accumulator instead of performing additional computation.

Example: Factorial Function

Let's convert a non-tail-recursive factorial function into a tail-recursive one.

Non-Tail-Recursive Version:

let rec factorial n =
  if n = 0 then 1
  else n * factorial (n - 1)  (* Multiplication is the last operation, so it's not tail recursive *)

Tail-Recursive Version:

let rec factorial_tail n acc =
  if n = 0 then acc
  else factorial_tail (n - 1) (acc * n)  (* The factorial_tail call is the last operation, so it's tail recursive *)

let factorial n = factorial_tail n 1;;

Explanation:

Accumulator: acc is introduced to store the intermediate result of the factorial computation.
Recursive Call: The recursive call factorial_tail (n - 1) (acc * n) is the last operation in the function, making it tail-recursive.
Base Case: When n = 0, the function returns the accumulator acc, which contains the final result.

Alternative Syntax:

A common way to write this in OCaml is:

let factorial n =
  let rec factorial_tail n acc =
    if n = 0 then acc
    else factorial_tail (n - 1) (acc * n)
  in
  factorial_tail n 1;;

Recursive and Parameterized Variants

In OCaml, you can create recursive variants to build more complex data structures. Let's create our own version of lists:

type intList =
  | Nil
  | Cons of int * intList;;

(* type intList = Nil | Cons of int * intList *)

Cons (1, Cons (2, Cons (3, Nil)));;
(* : intList = Cons (1, Cons (2, Cons (3, Nil))) *)

As you can see, intList is recursive, allowing the creation of recursive data structures, such as a list of integers. Let's see another example, this time creating a list of strings:

type stringList =
  | Nil
  | Cons of string * stringList;;

(* type stringList = Nil | Cons of string * stringList *)

Cons ("hola", Cons ("mundo", Nil));;
(* : stringList = ("hola", Cons ("mundo", Nil)) *)

To avoid creating a new variant for each type of list, we can use polymorphism to parameterize any kind of list:

type 'a customList =
  | Nil
  | Cons of 'a * 'a customList;;

(* type 'a customList = Nil | Cons of 'a * 'a customList *)

let int_list = Cons (1, Cons (2, Cons (3, Nil)));;
(* val int_list : int customList = Cons (1, Cons (2, Cons (3, Nil))) *)

let string_list = Cons ("hola", Cons ("mundo", Nil));;
(* val string_list : string customList = Cons ("hola", Cons ("mundo", Nil)) *)

To achieve this, we add the 'a type variable in front of the type name as 'a customList and use it wherever needed: 'a * 'a customList.

We can also generalize subsequent operations for any type of list:

let length lst =
  let rec length_tail acc = function
    | Nil -> acc
    | Cons (_, t) -> length_tail (acc + 1) t
  in
  length_tail 0 lst;;

(* val length : 'a customList -> int = <fun> *)

length int_list;;
(* : int = 3 *)

length string_list;;
(* : int = 2 *)

This type of variant is called parametric because it adapts to its changeable parts. The length function is parametric with respect to the type of the list.

In fact, this is how lists are defined in OCaml's standard library:

type 'a list =
  | []
  | (::) of 'a * 'a list;;

Lists in OCaml are recursive parameterized variants.

Error Handling

Errors are better handled as values instead of treating certain values as errors. This approach offers several advantages:

The program flow is not interrupted; it's redirected.
Functions remain pure, avoiding side effects.
You can handle values, not errors, making solutions more robust.
Null pointer exceptions are avoided.
Business logic is separated from error handling.

There are three ways to handle errors in OCaml:

Option values
Result values
Exceptions

Option Type

The option type represents a value that may or may not be present. It handles the absence of a value in a type-safe manner, avoiding the need for special sentinel values or null pointers.

Definition

The option type is a parametric variant that can have one of two forms:

type 'a option =
  | Some of 'a
  | None

'a: This is a type variable, meaning option can be used with any type.
Some: Indicates that a value is present.
None: Indicates that no value is present.

Usage

The option type is useful when a function might not return a valid result.

Example: Prevent Finding an Element in an Empty List

let rec find_element el = function
  | [] -> None
  | h :: t -> if el = h then Some h else find_element el t;;

(* val find_element : 'a -> 'a list -> 'a option = <fun> *)

find_element 3 [1; 2; 4];;
(* : int option = None *)

Summary:

You are explicitly telling your functions what to do in case of an undesirable input without crashing the program.

Result Type

The result type represents a computation that can succeed with a value or fail with an error. It is similar to the option type but provides more information in case of an error.

Definition

The result type is also a parametric variant that can have one of two forms:

type ('a, 'b) result =
  | Ok of 'a
  | Error of 'b

Ok value: Represents a successful computation with a value.
Error value: Represents a failed computation with an error value.

Usage

The result type is useful when you need to produce specific kinds of errors, making error handling more robust.

Example: Throwing an Error Value When Trying to Get the First Element in an Empty List

let first_element = function
  | [] -> Error "Empty list"
  | h :: t -> Ok h;;

(* val first_element : 'a list -> ('a, string) result = <fun> *)

first_element [];;
(* : ('a, string) result = Error "Empty list" *)

Example: Throwing an Error Value for Division by Zero

let safe_divide x y =
  if y = 0 then Error "division by 0"
  else Ok (x / y);;

(* val safe_divide : int -> int -> (int, string) result = <fun> *)

safe_divide 3 0;;
(* : (int, string) result = Error "division by 0" *)

Summary:

You are explicitly telling your functions what to do in case of an error without crashing the program.

Exceptions

Definition

Exceptions (exn) are a special type of variants called extensible variants. You can add constructors later on with the exception keyword:

exception SomethingHappened of string

SomethingHappened is a new constructor added to the type exn.

Raising an Exception

To raise an exception, call the raise function with a value from the constructor as an argument:

raise @@ SomethingHappened "Something went wrong"

Note that raise never returns a value; it interrupts the normal flow of the program and must be caught.

Catching Exceptions

The try ... with construct provides a clean separation for handling exceptions, allowing you to separate the "happy path" code from error-handling logic. Here's a general structure:

let safe_operation () =
  try
    Ok (some_risky_function ())
  with
    | EmptyList -> Error "Got an empty list"
    | Invalid_argument msg -> Error ("Invalid argument: " ^ msg)
    | _ -> Error "Unknown error occurred"  (** Catch-all pattern **)

Note: You can match specific exceptions and respond accordingly, or use _ to catch any unhandled exceptions.

Concrete Example: Safe Division

Let's say we want to divide two floats but avoid division by zero:

let div x y =
  if y = 0. then
    raise (Invalid_argument "Division by 0")
  else
    x /. y
;;
(* val div : float -> float -> float = <fun> *)

We can wrap it safely like this:

let safe_div x y =
  try
    Ok (div x y)
  with
    | Invalid_argument msg -> Error ("Invalid argument: " ^ msg)
    | _ -> Error "Unknown error occurred"
;;
(* val safe_div : float -> float -> (float, string) result = <fun> *)

So anytime y takes a value of 0, an Invalid_argument error is raised:

safe_div 3. 1.;;
(* : (float, string) result = Ok 3. *)

safe_div 3. 0.;;
(* : (float, string) result = Error "Invalid argument: Division by 0" *)

Extracting the Value:

If you need the value, you can use the built-in Result module to help you and pass a default value in case an error occurs:

let value = Result.value (safe_div 10. 0.) ~default:0.;;

Note: By building programs with errors in mind, we naturally create more robust software. It’s a form of testing as we code—we anticipate possible failures and plan how to handle them gracefully.

Mutations in OCaml

Sometimes side effects are necessary. Let's see how OCaml handles them:

References (Refs)

A reference is a pointer to a typed location in memory.

The binding to a pointer is: immutable.
The content of the memory location is: mutable.

Usage

Let's see the most basic operations you can do with references:

let value = ref 123;;  (** Create a new ref **)
(* val value : int ref = {contents = 123} *)

value := 321;;  (** Change the content **)
(* : unit = () *)

!value;;  (** Extract the content **)
(* : int = 321 *)

value := "mi piace la pizza!";;  (** Trying to change the content's type **)
(* Error: This constant has type string but an expression was expected of type int *)

The ref keyword creates a new reference.
The := operator assigns a new content to the reference.
The ! (bang) operator extracts the content of the reference.

Notice: Once defined, you can't change the type of a reference, so the last operation throws an error.

Aliasing

Aliasing occurs when two or more references point to the same location in memory.

Example:

let age = ref 32
let my_age = age;;  (** aliases **)

Both age and my_age point to the same location in memory. As a result, changing the content of age also changes my_age:

age := 34;;

!my_age;;
(* : int = 34 *)

Equality

Now you are prepared to understand the distinction between physical and structural equality:

Physical Equality

Evaluates the same location in memory:

let r1 = ref 123
let r2 = ref 123;;

(** Evaluates the same location in memory **)
r1 == r1;;
(* : bool = true *)

r1 != r2;;
(* : bool = true *)

It uses the == and != operators.

Structural Equality

Evaluates the same content in memory:

let r1 = ref 123
let r2 = ref 123;;

(** Evaluates the same content in memory **)
r1 = r1;;
(* : bool = true *)

r1 = r2;;
(* : bool = true *)

ref 123 <> ref 321;;
(* : bool = true *)

It uses the = and <> operators.

Sequence Operator (`;`)

The sequence operator allows you to execute multiple expressions in sequence, returning the value of the last expression.

expression1 ; expression2 ; expression3

In this sequence, all expressions are evaluated in order, but only the value of the last expression (expression3) is returned as the result of the entire sequence.

Example:

let result =
  print_string "Hello, ";
  print_string "OCaml!";
  42
;;

This evaluates to:

Prints "Hello, OCaml!" to the console.
Returns the integer value 42.

Usage

Side Effects: Since only the last value is returned and the previous values are discarded, their sole purpose is to produce side effects.

Counter Example

let counter = ref 0

let next = fun () ->
  counter := !counter + 1;
  !counter
;;

Or its syntactic sugar version:

let next () =
  incr counter;
  !counter
;;

next();;
(* : int = 1 *)

next();;
(* : int = 2 *)

Writing side effects in OCaml is beautiful. It uses special syntax that makes it expressive, helping you be conscious of possible side effects whenever you see them.

Bear in mind that this is not the only way to build a counter in OCaml. It can also be created through a closure:

let next =
  let counter = ref 0 in
  fun () ->
    incr counter;
    !counter
;;

Mutable Record Fields

type point = { x : float; y : float; mutable color : string }

let p1 = { x = 1.; y = 2.; color = "blue" };;
(* val p1 : point = { x = 1.; y = 2.; color = "blue" } *)

p1.color <- "red";;
(* : unit = () *)

p1;;
(* : point = {x = 1.; y = 2.; color = "red"} *)

This is possible because we declared color as a mutable field.

p1.x <- 0.;;
(* Error: The record field x is not mutable *)

The <- operator is used to mutate fields.

References in OCaml are essentially implemented as records with mutable fields:

type 'a ref = { mutable contents : 'a }
let ref x = { contents = x }  (* Returns a record with a mutable value *)

let (!) r = r.contents  (* Receives a record and returns its 'contents' field *)
let (:=) r newval = r.contents <- newval  (* Updates the mutable field 'contents' *)

Arrays

Arrays provide a way to store a fixed-size collection of elements of the same type, allowing for efficient random access and updates. Unlike lists, arrays are mutable, meaning you can change the value of an element after the array has been created.

let numbers = [|1; 2; 3; 4; 5|];;
(* val numbers : int array = [|1; 2; 3; 4; 5|] *)

Creating Arrays

let zeros = Array.make 5 0  (* zeros is [|0; 0; 0; 0; 0|] *)

let squares = Array.init 5 (fun i -> i * i)  (* squares is [|0; 1; 4; 9; 16|] *)

Accessing Array Elements

let first_element = numbers.(0)  (* first_element is 1 *)

Modifying Array Elements

numbers.(0) <- 10;
(* numbers is now [|10; 2; 3; 4; 5|] *)

Array Functions

Array.length

Returns the length of a given array.
Usage: Array.length array

Array.length [|1; 2; 3|];;
(* : int = 3 *)

Array.map

Applies a function to each element of an array and returns a new array with the results.
Usage: Array.map function array

Array.map (fun x -> x * 2) [|1; 2; 3|];;
(* : int array = [|2; 4; 6|] *)

Array.iter

Applies a given function to each element of an array for side effects, such as printing.
Usage: Array.iter func array

Array.iter (fun x -> Printf.printf "%d " x) [|1; 2; 3; 4|];;
(*  1 2 3 4 : unit = () *)

Array.fold_left and Array.fold_right

Fold functions that reduce an array to a single value using a binary function.
Usage: Array.fold_left func acc array

Array.fold_left (fun acc x -> acc + x) 0 [|1; 2; 3; 4|];;
(* : int = 10 *)

Basic OCaml

david2am — Wed, 02 Apr 2025 22:23:08 +0000

https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tx64r92ywj5o1mwg9k39.png

Welcome to this beginner-friendly OCaml tutorial! My goal is to make this your ultimate introduction to the language, covering all the fundamental concepts in a structured, easy-to-follow way. Each new topic builds upon the previous ones, ensuring a smooth learning experience.

References

Happy reading! 🚀

Index

Utop
SECTION 1: EXPRESSIONS AND DEFINITIONS
- Values
- If Expressions
- unit Type
- let Definitions
- let Expressions
- Anonymous Functions
- Named Functions
- High-Order Functions
- Recursive Functions
- Operators As Functions
SECTION 2: COMMON DATA STRUCTURES AND OPERATIONS
- Lists
- Tuples
- Records
SECTION 3: DIGGING IN OCAML
- Lexical Scope
- Parametric Polymorphism
- Variants
- Pattern Matching

Next Steps

Utop

To follow this tutorial, you can use Utop, OCaml's REPL (recommended), or Dune. Here, I'll explain how to configure Utop:

Ensure you have OCaml and its associated tools installed (refer to the guide /2. Ocaml in Dune.md).
Open a new terminal.
Run the command utop to start the interactive OCaml toplevel.

Additionally:

To evaluate an expression in Utop, end each expression with ;; and then press Enter.
To exit, execute the command #quit;;.

SECTION 1: EXPRESSIONS AND DEFINITIONS

In OCaml, expressions are code constructs that evaluate to a value without altering the program's state. Definitions introduce names and associate them with values, behaviors, types, or modules, known as bindings.

Values

A value is an expression that doesn't need further evaluation. Let's explore some examples in OCaml:

Integers

1;;
(* : int = 1 *)

1 + 4;;
(* : int = 5 *)

Int.to_string 14;;
(* : string = "14" *)

Int.max 3 7;;
(* : int = 7 *)

Booleans

false;;
(* : bool = false *)

3 > 2;;
(* : bool = true *)

Bool.to_string true;;
(* : string = "true" *)

Chars

'd';;
(* : char = 'd' *)

Strings

"hola!";;
(* : string = "hola" *)

"hola" ^ " mundo!";;
(* : string = "hola mundo!" *)

"hola".[2];;
(* : char = 'l' *)

String.length "hola mundo!";;
(* : int = 11 *)

String.uppercase_ascii "hola mundo!";;
(* : string = "HOLA MUNDO!" *)

Floats

1.0;;
(* : float = 1.0 *)

1.0 +. 4.0;;
(* : float = 5.0 *)

Float.of_string "14";;
(* : float = 14. *)

Float.round 6.2;;
(* : float = 6. *)

OCaml distinguishes between integer and float operators, which helps the language infer type definitions directly from used operators. For example:

2.5 *. 5. is valid.
7.5 +. 3 is invalid because the operator +. requires both numbers to be of type float.

Note:

OCaml includes built-in modules for common operations, such as Float.round and String.length. For more information, visit The OCaml API.

If Expressions

If expressions conditionally evaluate one branch over another. In OCaml, if expressions always return a value because their branches are expressions, and the else clause is mandatory.

if condition then ifBranch else elseBranch;;
(* if condition is true then returns ifBranch *)
(* if condition is false then returns elseBranch *)

if "pineapple pizza" > "pizza margherita" then "Non sei italiano" else "Tu sei un vero italiano";;
(* : string = "Tu sei un vero italiano" *)

Particularities

condition expression should evaluate to boolean.
Both branch expressions should have the same type.
else branch is required.

if 0 then "Non sei italiano" else "Tu sei un vero italiano";;
(* Error: value 0 is not a boolean expression *)

if true then "Non sei italiano" else 1;;
(* Error: "Non sei italiano" and 1 have different types *)

if true then "Non sei italiano";;
(* Error: else branch is not provided *)

`unit` Type

The unit type is equivalent to void in other programming languages but is a valid type in OCaml. It has only one possible value, denoted by ().

print_endline "Hello, world!";;
(* Hello, world! *)
(* : unit = () *)

`let` Definitions

let definitions are bindings that are always immutable.

let greet = "Ciao!";;
(* val greet : string = "Ciao!" *)

Note:

The utop response indicates that "Ciao!" is a string bound to a value definition called greet (it's readed from right to left).

`let` Definitions Are Immutable

let pi = 3.1;;
(* val pi : float = 3.1 *)

pi = 3.1415;;
(* : bool = false *)

let pi = 3.1415;;
(* val pi : float = 3.1415 *)

The result of pi = 3.1 may seem strange but satisfies immutability:
- you can't mutate a let definition
- In OCaml, = is the boolean comparison operator.
let pi = 3.1415 creates a new memory allocation with the same name pi, so it's not a mutation but a re-definition.

`let` Expressions

Let expressions allow you to bind subexpressions within a larger expression using a name. In OCaml, the in keyword indicates that the preceding is a subexpression that can be used in subsequent expressions.

This concept is similar to mathematical substitution, where you replace variables with their values:

let x = 7 in 3 + x;;
(* : int = 10 *)

(*
   You can think of this as a kind of mathematical substitution:

   let x = 7

   in: 3 + x
   is: 3 + 7
   resolves to: 10
 *)

Let expressions can be used with any type of value, not just integers. For example:

let greet = "salve" in greet ^ " mondo!";;
(* val greet : string = "salve mondo!" *)

`let` Expression Scope

Scope refers to the region of a program where a binding is meaningful and can be accessed. In other words, it's where you can substitute a binding with its value.

Let's revisit an example with a fresh perspective:

let x = 7 in let y = 3 in x + y;;
                         <- A ->
             <------- B ------->
<-------------- C ------------->
(* Where A is a subexpression of B, and B a subexpression of a bigger expression C *)

In this example:

x is meaningful within subexpression B, but not before.
Similarly, y is meaningful within subexpression A, but not before.

As OCaml follows lexical scoping rules, the most recent definition of a binding takes precedence:

let x = 10 in let x = 5 in x ;;
(* : int = 5 *)

Note:

More into scoping is the Lexical Scope section of this article.

Anonymous Functions

Anonymous functions, also known as lambda functions, are expressions that contain behavior. They are particularly useful for creating short, one-off functions that are often passed as arguments to higher-order functions. In OCaml, anonymous functions are defined using the fun keyword:

fun x -> x + 10;;
(* : int -> int = <fun> *)

This anonymous function takes an integer x and returns x + 10.
The type signature int -> int indicates that the function takes an integer as input and returns an integer.

Now let's pass an argument to the function:

(fun x -> x + 10) 35;;
(* : int = 45 *)

In OCaml, you do not need to use parentheses to invoke a function.
Here, 35 is passed to the anonymous function, resulting in 45.

Additionally, let expressions can be seen as syntactic sugar for function applications:

(* Both expressions are equivalent: *)
let x = 35 in x + 10;;
(fun x -> x + 10) 35;;

The let expression binds x to 35 and then evaluates x + 10.
The anonymous function does the same by directly applying 35 to the function body.

Named Functions

In OCaml, anonymous functions are values, and using the let keyword, you can create a binding:

let sum_10 = fun x -> x + 10
(* val sum_10 : int -> int = <fun>  *)

Alternatively, you can use a more concise syntax by placing the arguments on the left side of the equal sign and omitting the fun and -> keywords:

let sum_10 x = x + 10
(* val sum_10 : int -> int = <fun>  *)

This syntax achieves the same result but is more concise and readable.

High-Order Functions

High-order functions are functions that take other functions as arguments or return them as results. They are a fundamental concept in functional programming and allow for greater abstraction and code reuse.

The List.map function is a classic example of a high-order function. It applies a given function to each element of a list and returns a new list with the results.

let increment x = x + 1;;

List.map increment [1; 2; 3; 4];;
(* : int list = [2; 3; 4; 5] *)

Explanation:

List.map takes two arguments: a function (increment) and a list ([1; 2; 3; 4]).
It applies the increment function to each element of the list, returning a new list with the incremented values.

High-order functions enable you to write more modular and reusable code by abstracting common patterns of computation.

Closures

Closures refer to the ability of a function to capture and "remember" the environment in which it was created. This means that a function can access variables from its surrounding scope, even after that scope has finished executing.

Example: Multiplier Function

let make_multiplier factor =
  fun x -> x * factor

let double = make_multiplier 2
let triple = make_multiplier 3

double 5;;
(* : int = 10 *)

triple 5;;
(* : int = 15 *)

Explanation:

make_multiplier is a function that takes a factor and returns another function.
The returned function is a closure that captures the factor from its surrounding scope.
double and triple are instances of this closure, each capturing a different value for factor.
When you call double 5, it multiplies 5 by 2 (the captured factor), resulting in 10.
Similarly, triple 5 multiplies 5 by 3, resulting in 15.

Partial Applications

In OCaml, functions that take multiple arguments do not use commas to separate the arguments. Instead, arguments are separated by spaces, and functions that seem to take multiple arguments are actually several nested functions that take one argument at a time. This is called "currying."

fun x y -> x + y;;
(* : int -> int -> int = <fun> *)

(* is syntactic sugar of: *)
fun x -> (fun y -> x + y);;
(* : int -> int -> int = <fun> *)

This is evident in their type definition: : int -> int -> int, which is essentially a function that returns another function : int -> (int -> int).

Creating Specialized Functions

You can use partial application to create specialized functions. For example, you can create a function add_4 that always adds 4 to any number:

let add x y = x + y;;
(* val add : int -> int -> int = <fun> *)

let add_4 = add 4;;
(* val add_4 : int -> int = <fun> *)

add_4 8;;
(* : int = 12 *)

add_4 10;;
(* : int = 14 *)

The function add takes two integers, x and y, and returns their sum.
The type signature int -> int -> int indicates that add is a function that takes an integer and returns another function that takes an integer and returns an integer.
By partially applying the add function with the argument 4, you create a new function add_4 that only requires one argument, simplifying its usage.

Recursive Functions

Imagine climbing a staircase from the ground floor to the first floor. You take each step one at a time. To reach the second step, you must first step onto the first. Similarly, to reach the third step, you must first be on the second step. Each step forward builds on the previous steps, creating a repeated sequence with a consistent pattern between each step. This concept illustrates recursion, where a problem is solved by breaking it down into smaller, similar sub-problems.

(Example inspired by Byjus).

                       o
                      /|\
                ___ 4 / \
            ___| 3
        ___| 2
    ___| 1
___| ground

Step 2 = Step 1 + ground floor

Step 3 = Step 2 + step 1 + ground floor

And so on.

Functional programming prefers recursive functions over loops because they can be pure functions that call themselves without producing side effects, or at least producing only external side effects.

A recursive function has two parts:

Base Case: Defines the simplest version of the problem, which stops the recursion.
Recursive Case: Defines the nth term, how the function calls itself with a smaller input, progressively reducing the problem toward the base case.

Example
In OCaml, you must explicitly use the rec keyword when defining a recursive function:

let rec factorial n =
  if n = 0 then 1 (* base case *)
  else n * factorial (n - 1);; (* recursive case *)
(* val factorial : int -> int = <fun> *)

Breakdown:

Base Case: The function stops when n = 0, returning 1. This prevents infinite recursion.
Recursive Case: The function calls itself with n - 1, reducing the problem step by step until it reaches the base case.

Operators As Functions

In OCaml, operators are essentially functions. This means you can use them in the same way you use any other function, allowing for greater flexibility in your code. There are two primary ways to use operators:

Infix Notation: This is the typical way operators are used, where the operator is placed between the operands.

   1 + 5;;
   (* : int = 6 *)

Prefix Notation: By enclosing the operator in parentheses, you can use it as a function, passing the operands as arguments.

   ( + ) 1 5;;
   (* : int = 6 *)

Benefits of Using Operators as Functions

Partial Application: You can partially apply operators to create new functions.

  let add_five = ( + ) 5;;
  (* val add_five : int -> int = <fun> *)

  add_five 3;;
  (* : int = 8 *)

Consistency: Treating operators as functions maintains a consistent functional programming style, making your code more predictable and easier to reason about.

Application Operator

The application operator (@@) allows you to avoid writing parentheses, making expressions cleaner and easier to read. It is defined as follows:

let (@@) f g = f g

Consider the following function and expressions:

let add x y = x + y;;

add 2 5 * 4;;
(* Result: int = 28, not the desired outcome due to operator precedence *)

add 2 (5 * 4);;
(* Result: int = 22, correct but requires parentheses *)

add 2 @@ 5 * 4;;
(* Result: int = 22, using the application operator for clarity *)

Reverse Application (Pipeline)

The reverse application operator, also known as the pipeline operator (|>), allows you to write operations from left to right in a more natural and readable manner. It is defined as follows:

let (|>) f g = g f

Consider the following functions and expressions:

let add x y = x + y;;
let square x = x * x;;

square (square (add 5 10));;
(* Result: int = 50625, nested function calls, read from right to left *)

5 |> add 10 |> square |> square;;
(* Result: int = 50625, using the pipeline operator for readability *)

SECTION 2: COMMON DATA STRUCTURES AND OPERATIONS

Lists

Lists in OCaml provide a simple and efficient way to manage sequences of elements. They are particularly well-suited for functional programming due to their immutability and support for recursive operations. Lists are especially efficient for operations that involve adding or removing elements at the beginning.

Defining Lists

A list in OCaml is defined using square brackets, with elements separated by semicolons. Lists can contain elements of any type, but all elements in a single list must be of the same type.

[];;
(* : 'a list = [] *)

[1; 2; 3];;
(* : int list = [1; 2; 3] *)

[1.; 2.; 3.];;
(* : float list = [1.; 2.; 3.] *)

[true; false; true];;
(* : bool list = [true; false; true] *)

[[1; 2]; [3; 4]; [5; 6]];;
(* : int list list = [[1; 2]; [3; 4]; [5; 6]] *)

Note:

The empty list is of type 'a list, where 'a is a type variable. It acts as a generic type that gets specialized based on the elements it contains. More of this in the Parametric Polymorphism section of this article.

Cons Operator (`::`)

Appends an element in front of a list:

0 :: [1; 2; 3];;
(* : int list = [0; 1; 2; 3] *)

Note:

[0; 1; 2; 3] is a new list.
[0; 1; 2; 3] is syntactic sugar for 0 :: 1 :: 2 :: 3 :: [].
In the new list, 0 is called the head, and [1; 2; 3] is called the tail.

Append Operator (`@`)

Combines two lists into one:

[0; 1] @ [2; 3];;
(* : int list = [0; 1; 2; 3] *)

List Module

The List module in OCaml provides a collection of functions to work with lists. Here are some of them:

List.map: Applies a given function to each element of a list and returns a new list with the results.

Usage: List.map func list

List.map (fun x -> x * x) [1; 2; 3; 4];;
(* : int list = [1; 4; 9; 16] *)

List.mem: Checks whether a given element is a member of a list.

Usage: List.mem element list

List.mem 3 [1; 2; 3; 4];;
(* : bool = true *)

List.find: Returns the first element of a list that satisfies a given predicate. Throws a Not_found exception if no such element is found.

Usage: List.find predicate list

List.find (fun x -> x mod 2 = 0) [1; 3; 5; 4; 6];;
(* : int = 4 *)

List.filter: Returns a new list containing only the elements that satisfy a given predicate.

Usage: List.filter predicate list

List.filter (fun x -> x mod 2 = 0) [1; 2; 3; 4; 5];;
(* : int list = [2; 4] *)

List.length: Returns the length of a list.

Usage: List.length

List.length [1; 2; 3];;
(* : int = 3 *)

List.fold_left and List.fold_right: Fold functions that reduce a list to a single value using a binary function.

Usage: List.fold_left func acc list

List.fold_left (fun acc x -> acc + x) 0 [1; 2; 3; 4];;
(* : int = 10 *)

Tuples

Tuples are a simple and useful way to aggregate data, which can be of different types. They are especially suitable for temporary groupings or when the order of elements is meaningful.

Here is how you can define a tuple:

let alice = ("Alice", 30, "alice@email.com");;
(* val alice : string * int * string = ("Alice", 30, "alice@email.com") *)

Optionally, you can specify custom reusable types for your tuples:

type person = string * int * string

let alice : person = ("Alice", 30, "alice@email.com");;
(*
   type person = string * int * string
   val alice : person = ("Alice", 30, "alice@email.com")
 *)

Accessing Tuple Elements

let (name, age, email) = alice;;
(*
   val name : string = "Alice"
   val age : int = 30
   val email : string = "alice@email.com"
 *)

Alternatively, you can use functions like fst and snd to access the first and second elements of a pair (a 2-element tuple):

let point = (1, 3)

let x = fst point
let y = snd point;;
(*
   val point : int * int = (1, 3)
   val x : int = 1
   val y : int = 3
 *)

Records

Records are a powerful way to group related data into a single unit with named fields. Unlike tuples, which use positional access, records allow you to access data by field names, making your code more readable and maintainable.

Usage:

Create the type definition that specifies the names and types of the fields that the record will contain.
Create instances of that record by specifying values for each field.

type person = {
  name : string;
  age : int;
  email : string;
}

let paolo = {
  name = "paolo";
  age = 32;
  email = "paolo@email.com";
};;
(*
   type person = { name : string; age : int; email : string; }
   val paolo : person = { name = "paolo"; age = 32; email = "paolo@email.com" }
 *)

Note:

OCaml automatically knows that paolo is a person. You can explicitly state it, but it's not strictly necessary for records.

Accessing Record Elements

Direct Access

paolo.name;;
(* : string = "paolo" *)

paolo.age;;
(* : int = 32 *)

paolo.email;;
(* : string = "paolo@email.com" *)

Destructuring

let { name; age } = paolo;;
(*
   val name : string = "paolo"
   val age : int = 32
 *)

SECTION 3: DIGGING IN OCAML

Lexical Scope

OCaml adheres to lexical scoping, also known as static scoping. This means that the scope of a variable is determined at compile time based on the structure of the code, rather than at runtime based on the execution context. Lexical scoping simplifies reasoning about code, as it eliminates the need to track the dynamic context, unlike dynamic scoping where the scope is resolved at runtime.

Scope for Function Arguments

Function arguments in OCaml are local to the function and cannot be accessed outside its body. Additionally, OCaml function parameters are passed as value copies, not as references to the original arguments. This design prevents unintended modifications to the original data, enhancing both safety and predictability.

Locality of Bindings

Bindings defined within a function are local to that function and cannot be accessed outside of it.
Bindings introduced within a let expression are local to that expression.
Bindings defined at the top level (global scope) are accessible throughout the module.

Lexical Scoping and Closure

OCaml functions can capture bindings from their surrounding scope, even after that scope has exited. This feature, known as a closure, allows functions to retain access to variables from their defining environment. Captured variables are generally immutable within the closure, ensuring consistency across different function executions. This immutability reduces shared-state complexity and helps prevent race conditions in concurrent programs.

Parametric Polymorphism

Parametric polymorphism is a way to write generic, type-agnostic code. This is achieved using Type Variables.

Type Variables

Type variables are placeholders for types. They allow you to define functions and data structures that can operate on any type. In OCaml, type variables are typically denoted by single letters like 'a, 'b, etc., often read as alpha, beta, etc.

let identity x = x;;
(* val identity : 'a -> 'a *)

Here, 'a (alpha) is a type variable representing an unknown type in OCaml.

This type variable allows the identity function to operate on values of any type, making it a polymorphic function.

Maybe you remember the type definition of the empty list:

[];;
(* : 'a list = [] *)

Here it's saying: "I'm a list that can be of any type", but it gets specialized when it receives elements:

"hola" :: [];;
(* : string list = ["hola"] *)

Aliases

Like values you can give name to types:

type point = float * float;;
(* type point = float * float *)

let p1 : point = (1., 2.);;
(* val p1 : point = (1., 2.) *)

Variants

OCaml supports features called variants or algebraic data types (ADTs) that are very similar to enums in other languages. Variants are used to define types that can take on different forms, allowing you to create new type definitions.

type primary_color = Red | Green | Blue;;
(* type primary_color = Red | Green | Blue *)

let r = Red;;
(* val r : primary_color = Red *)
let g = Green;;
(* val g : primary_color = Green *)
let b = Blue;;
(* val b : primary_color = Blue *)

Here we are defining a custom type primary_color that can be one of three options: Red, Green and Blue. These options are called contructors and serve as custom tags. In the first examples, we are binding one of those tags to a name and doing so the compiler interpret those bindings as types from primary_color.

Constructors can optionally carry data, allowing you to create more complex data structures. Let's see the next example:

type shape =
  | Point;;                     (* A point with no additional data *)
  | Circle of float             (* Circle with a radius *)
  | Rectangle of float * float;;(* Rectangle with width and height *)
(* type shape = Circle of float | Rectangle of float * float | Point *)

let p = Point;;
(* val p : shape = Point *)

let c = Circle 5.0;;
(* val c : shape = Circle 5. *)

let r = Rectangle (3.0, 4.0);;
(* val r : shape = Rectangle (3., 4.) *)

Circle, Rectangle, and Point are the variant constructors.
Point carries no additional data (similar to the primary_color example).
Circle carries a single float value representing the radius.
Rectangle carries two float values representing the width and height.

Constructors as you can see allow you to create new values from a variant type, different definition from constructors in OOP (Object Oriented Programming), which also contains methods.

Pattern Matching

Pattern matching allows you to inspect the structure of data and extract values in a concise and expressive way. It's particularly useful for working with algebraic data types, such as variants and tuples. Pattern matching allows you to:

Match against values (pretty similar to switch cases)
Match against the shape of the data
Extract parts of the data

Syntax

The basic syntax for pattern matching in OCaml is:

let fun_name expression =
match expression with
| pattern1 -> result1 (* we call this a branch *)
| pattern2 -> result2
| ...

(* or its equivalent syntactic sugar *)
let fun_name expression = function
| pattern1 -> result1 (* we call this a branch *)
| pattern2 -> result2
| ...

expression is the value you want to match against.
pattern1, pattern2, etc., describe the shape of the data.
result1, result2, etc., are the returned expressions if the corresponding pattern matches.

Side Note:
The entire match expression must be type-consistent, meaning all branches must return values of the same type, just like OCaml’s if expressions.

Matching on Values

Pattern matching on values are very similar to switch cases but more powerful. In fact understanding switch cases is a good place to start.

let describe_number x =
  match x with
  | 0 -> "Zero"
  | 1 -> "One"
  | _ -> "Some other number";;
(* val describe_number : int -> string = <fun> *)

describe_number 1;;
(* : string = "One" *)

describe_number 42;;
(* : string = "Some other number" *)

Explanation:

The function describe_number takes an integer x.
It matches x against several patterns: 0, 1, and _ which is a wildcard pattern that matches anything.

More Powerful than Switch Cases

Allows you to match not just on values but also on the structure of data.
Can warn you if you haven't covered all possible cases.
Often results in shorter and more readable code.
Does not have fall-through behavior, where forgetting a break statement can lead to unintended execution of subsequent cases.

Matching on Lists

Lists can only be:

nil ([])
the cons of an elemnt onto another list (h :: t)

So we can pattern match against those to ways:

let first_element lst =
  match lst with
  | [] -> "empty"
  | h :: t -> h;;
(* val first_element : string list -> string = <fun> *)

first_element [];;
(* : string = "empty" *)

first_element ["sapori"; "colori"];;
(* : string = "sapori" *)

Explanation:

The function get_first_element takes a list lst.
It matches the list against several patterns:
- [] (empty list) → returns "empty".
- [x] (single-element list) → returns x.
- h :: _ (non-empty list) → returns the first element h.

Side Note:

In fact, pattern matching is type exaustive, preventing to write runtime error prone code:

let first_element lst =
  match lst with
  | [] -> "empty";;
(*
  [partial-match]: this pattern-matching is not exhaustive.
  Here is an example of a case that is not matched:
  _::_

  val first_element : 'a list -> string = <fun>
 *)

Matching on Tuples

let has_zero (x, y) =
  match (x, y) with
  | (0, 0) -> "Both are zero"
  | (0, _) -> "First is zero"
  | (_, 0) -> "Second is zero"
  | _ -> "None is zero";;
(* val has_zero : int * int -> string = <fun> *)

has_zero (7,4);;
(* : string = "None is zero" *)

has_zero (0, 1);;
(* : string = "First is zero" *)

Explanation:

The function has_zero takes a tuple (x, y) and matches it against specific patterns to determine whether any of the values are zero.

Example: Matching on Records

type student = {
  name : string;
  grad_year : int;
}

let giorgio : student = {
  name = "Giorgio Rosa";
  grad_year = 1950
};;
(*
  type student = { name : string; grad_year : int; }
  val giorgio : student = {name = "Giorgio Rosa"; grad_year = 1950}
 *)

let name_with_year record =
  match record with
  | { name; grad_year } -> name ^ ", graduated in " ^ Int.to_string grad_year;;
(* val name_with_year : student -> string = <fun> *)

name_with_year giorgio;;
(* : string = "Giorgio Rosa, graduated in 1950" *)

Example: Matching on Variants

type shape =
  | Circle of float
  | Rectangle of float * float

let area shape =
  match shape with
  | Circle radius -> Float.pi *. radius ** 2.
  | Rectangle (width, height) -> width *. height;;
(*
   type shape = Circle of float | Rectangle of float * float
   val area : shape -> float = <fun>
 *)

area @@ Circle 3.0;;
(* : float = 28.27... *)
area @@ Rectangle (2.0, 4.0);;
(* : float = 8. *)

Explanation:

The shape type has two variants: Circle and Rectangle.
The function area matches on the shape and extracts the relevant data:
- Circle radius → computes the area as π * radius².
- Rectangle (width, height) → computes the area as width * height.

Example: Nested Patterns

Let's calculate the area of shapes when we have its cartesian points:

type point = float * float

type shape =
  | Circle of { center: point; radius: float }
  | Rectangle of { lower_left: point; upper_right: point }

let area shape =
  match shape with
  | Circle { center; radius } -> Float.pi *. radius ** 2.
  | Rectangle { lower_left; upper_right } ->
      let (x_lf, y_lf) = lower_left in
      let (x_ur, y_ur) = upper_right in
      (x_ur -. x_lf) *. (y_ur -. y_lf);;
(*
   type point = float * float
   type shape =
     Circle of { center : point; radius : float; }
   | Rectangle of { lower_left : point; upper_right : point; }
   val area : shape -> float = <fun>
 *)

area @@ Circle { center = (0. , 0.); radius = 1. };;
(* : float = 3.14159265358979312 *)

In this case we are extracting data from the record of a variant constructor but we can pattern match even more :

type point = float * float

type shape =
  | Circle of { center: point; radius: float }
  | Rectangle of { lower_left: point; upper_right: point }

let area shape =
  match shape with
  | Circle { center; radius } -> Float.pi *. radius ** 2.
  | Rectangle {
      lower_left = (x_lf, y_lf);
      upper_right = (x_ur, y_ur)
    } -> (x_ur -. x_lf) *. (y_ur -. y_lf);;

Function Keyword

You can simplify the syntax of functions that use pattern matching by leveraging the function keyword. This keyword allows you to leave off the last argument and the beginning of the match expression, making your code more concise and readable.

Simplifying with `function`

Consider the following function definition:

let f x y z =
  match z with
  | ...

You can rewrite it using the function keyword to streamline the pattern matching:

let f x y = function
  | ...

Let's take the previous example:

type shape =
  | Circle of float
  | Rectangle of float * float

let area = function    (* see the change here *)
  | Circle radius -> Float.pi *. radius ** 2.
  | Rectangle (width, height) -> width *. height;;
(*
   type shape = Circle of float | Rectangle of float * float
   val area : shape -> float = <fun>
 *)

Explanation:

Type Definition: The shape type is a variant that can represent either a Circle with a radius or a Rectangle with width and height.
Function Definition: The area function uses the function keyword to directly pattern match on the shape type. This eliminates the need for an explicit match expression.
Usage:

area @@ Circle 3.0;;
(* : float = 28.27... *)
area @@ Rectangle (2.0, 4.0);;
(* : float = 8. *)

Example: Summing a List

Here's another example that demonstrates the use of the function keyword with a recursive function to sum the elements of a list:

let rec sum = function
 | [] -> 0
 | h :: t -> h + sum t

Explanation:

Function Definition: The sum function uses the function keyword to pattern match on the list. If the list is empty ([]), it returns 0. Otherwise, it adds the head (h) to the sum of the tail (t).
Usage:

sum [1; 2; 3; 4];;
(* : int = 10 *)

Congratulations

You've arrived at the final part of the article. Now you have the big picture of OCaml and can write your own code!

Next Steps

If you want to dig more into OCaml particularities visit the second part Practical OCaml

Functional Programming and Why OCaml?

david2am — Wed, 02 Apr 2025 22:19:54 +0000

I'd like to express my gratitude to Richard Feldman for his incredible teachings in Functional Programming and to Professor Michael Ryan Clarkson for creating such a wonderful OCaml's course.

With this guide, I hope to contribute to the community by showcasing the beauty and practicality of functional programming, emphasizing that it's different, not difficult. There's a lack of beginner-friendly tutorials out there, and I aim to fill that gap.

References

Index

Imperative vs Declarative Programming
Functional Programming Basics
Implementations of FP in a Language
Concurrency and Parallelism the Places where FP Shines
OCaml
Next Steps

Happy reading! 🚀

Imperative vs Declarative Programming

Think of it like cooking:

Imperative programming is like giving detailed step-by-step cooking instructions:

Take out a pan
Heat it to medium
Add 1 tablespoon of oil
Crack 2 eggs into the pan
Stir for 2 minutes
Add salt and pepper

Declarative programming is like saying "Make me scrambled eggs, please" - you specify what you want, not how to do it.

Functional Programming (FP) is a declarative way of writing programs. It focuses on telling the computer what result you want, hiding the detailed mechanics of how to get there.

This makes your code more:

Expressive
Easy to read
Easier to maintain
More focused on solving problems than implementation details

Note:

Some may be concerned that the higher level of abstraction in functional programming (FP) could lead to slower programs. However, this is not always the case. For instance, OCaml, a functional language, can achieve performance comparable to that of C.

Functional Programming Basics

Like math formulas, expressions evaluate to values. In FP, everything is an expression, including functions, so programs are just compositions of expressions, rather than instructions, as in imperative programming.

Core Principles of FP

✅ No Side Effects

✅ No Shared State

✅ Immutable Data

No Side Effects

In general, there are 2 types of side effects external and internal. External side effects occurs when a program interacts with the external world, such as reading from a file, writing to a database, or displaying output. On the other hand, internal side effects occurs when a code entity (function, method, object, etc.) mutate state outside its own scope.

            outside
              |
outside <-  SYSTEM  -> outside
              |
            outside

FP discourage the use of internal side effects because they can lead to unexpected behaviors. In another hand, external side effects are unavoidable because are necessary to interact with the real world.

Example:

(* Function with side effect - prints to console *)
let greet name =
  print_string ("Hello, " ^ name ^ "!\n")

(* Pure function - no side effect *)
let greeting name =
  "Hello, " ^ name ^ "!"

No Shared State

Expressions do not share state directly; instead, they operate on copies of data, ensuring modifications in one of them don't generate side effects in another.

Example:

(* Define a function that takes a list and returns a new list with an element added *)
let add_element lst elem =
  elem :: lst

Immutable Data

In functional programming, data is immutable, meaning it cannot be changed once created. If updates are necessary, new versions of the data are generated. Since each expression operates on a copy, internal operations do not affect the original data.

Example:

(* Immutable list operations *)
let numbers = [1; 2; 3]
let added = 0 :: numbers     (* Creates new list [0; 1; 2; 3] *)
let mapped = List.map (fun x -> x * 2) numbers  (* Creates new list [2; 4; 6] *)

(* Original list remains unchanged *)
(* numbers is still [1; 2; 3] *)

Implementations of FP in a Language

To apply those principles FP uses:

✅ * Expressions

✅ * Lexical Scope

✅ Pure Functions

✅ First-Class Functions

FP revolves around the use of expressions and lexical scope. Pure functions and closures are natural byproducts of expressions and well-defined scope.

While not covered here, these concepts also serve as the foundation of recursion, partial applications (or currying), lazy evaluation and more, which we will explore in depth in a future article.

Expressions

Expressions are code constructs that evaluate to a value without altering the program's state. In FP, even control structures like if-then-else return values!

Examples:

(* Pseudocode for expressions *)
let val1 = expression_1 (* evaluates to a value *)
let val2 = expression_2 (arg = val1) (* expression_2 uses copies of val1 without modifying them *)


(* Pseudocode for instructions *)
let val1 (* value declaration *)

computation_1 (* modifies val1 *)

let val2 (* value declaration *)

computation_2 (arg = val1) (* modifies val2 *)

As illustrated, traditional computations can lead to side effects, making code harder to maintain. On the other hand, expressions always return values, encouraging that evaluation take place outside their scope, avoiding mutations and side effects on other internal scopes.

Lexical Scope

In lexical scoping, the scope of a variable is determined by its location within the source code, specifically where it is declared. This means that the scope is resolved at compile time based on the structure of the code, rather than at runtime based on the execution context, which makes it easier to reason about in comparison with dynamic scoping for example.

Function Parameters

Internally, they act as value copies rather than references to the original arguments. This prevents unintended modifications to the original data.

Local variables and immutability

Variables declared within a specific scope (such as inside a function) are intended to be immutable, reinforcing predictability and referential transparency.

Lexical Scoping and Closure

When a higher-order function creates a closure, it captures variables from its surrounding scope. These captured variables are usually treated as immutable within the closure, ensuring they remain consistent across different function executions. This also helps prevent unexpected modifications from other parts of the program, reducing shared-state complexity and race conditions in concurrent execution.

Pure Functions

Pure functions always produce the same output for the same input and have no side effects - just like mathematical functions!

Example:

(* Pure function *)
let square x = x * x

(* Always returns 16 *)
square 4

In other words, are expressions that have no side effects at all.

First-Class Functions

In functional programming, functions are a special type of value. This means they can be passed as arguments, returned from other functions, and assigned to variables. Functions that take other functions as arguments or return functions as results are called higher-order functions. These enable function composition and closure creation, which, as discussed earlier, establish their own scope and help avoid shared state between entities.

Example:

(* A function that takes another function as input *)
let apply_twice f x = f (f x)

(* Passing different functions to apply_twice *)
let result1 = apply_twice (fun x -> x * 2) 3    (* Returns 12 *)
let result2 = apply_twice (fun x -> x ^ "!") "hi"  (* Returns "hi!!" *)

Concurrency and Parallelism the Places where FP Shines

Whenever you need better fault tolerance and availability you need concurrency and/or parallelization, and their best fit is FP because it offers:

✅ Safe Parallelization

✅ Safe Data Sharing

✅ Sage Threads

Safe Parallelization

Since FP avoids side effects, operations can run independently over iterable data structures, such as arrays, tuples, etc, without fearing unexpected behaviors.

Example:

(* Can safely run parallel_function_expression independently over each list element because no shared state is modified *)
let processed_customers = 
  List.map (parallel_function_expression) customers

Safe Data Sharing

Since data is immutable (unchangeable), it can be safely shared across different parts of your program.

Example:

(* This data can be shared safely across threads *)
let data = [("timeout", "30"); ("retries", "3")]

(* Every thread can access 'data' without worrying about it changing *)

Thread Safety

Immutable data prevents race conditions (where multiple threads try to modify the same data simultaneously).

Example:
In languages with mutable data:

# Potential race condition if two threads run this
counter += 1

In functional programming:

(* No race condition - creates new value instead of modifying *)
let new_counter = counter + 1

Ocaml

OCaml's approach makes functional programming both powerful and accessible. While it may differ from what you're used to, with practice, it becomes an intuitive and effective way to write clean, reliable code!

Why Choose OCaml for Functional Programming?

✅ Balanced FP

✅ Correctness

✅ Speed (as fast as C)

Balanced FP

OCaml allows mutation when it's truly necessary. For specific use cases, creating a long data list every time a change is needed can be inefficient. Therefore, OCaml allows you to prioritize performance over dogmatic adherence to immutability:

Example:

(* Imperative style with shared state *)
let counter = ref 0
let increment () = counter := !counter + 1

(* Functional style - no shared state *)
let increment count = count + 1

But OCaml still adheres to FP principles:

✔︎ No Side Effects

✔︎ No Shared State

✔︎ Immutable Data

An also their advantage for fault tolerance and high availability systems are maintained:

✔︎ Safe Parallelization

✔︎ Safe Data Sharing

✔︎ Safe Threads

Correctness

OCaml's strong type system adds an extra layer to detect errors at compile time, preventing security vulnerabilities and enhancing code clarity and readability. It is so powerful that you often don't need to explicitly define every type; the compiler can infer types from your code.

Example:

(* OCaml won't let this run. The '+' operator works with numbers, not strings, so `x` is expected to be a number. *)
let buggy x = x + "hello"  (* Type error! *)

(* The type system helps you write correct code. *)
let safe_concat x = string_of_int x ^ "hello"  (* Works correctly *)

As demonstrated, explicit type definitions are often unnecessary due to OCaml's type inference capabilities.

Speed

OCaml is renowned for its performance, often achieving speeds comparable to C. This makes it an excellent choice for applications where efficiency is critical.

🟣 Next Steps

If you want to explore and build your first OCaml project visit my tutorial OCaml/Dune
If you want to explore OCaml syntax visit my tutorial Basic OCaml

Forem: david2am

OCaml in 5 Minutes: From Zero to 'Hello'

Index

🟣 Global Setup

Install OCaml

For macOS

For Linux

Initialize OCaml's global configuration:

Load Opam's Environment:

Install Platform Tools

🟣 Create a New Project

Create a new project

Create a Switch

Activate the Switch

Install Dev Tools for the Switch

Enable Automatic Switch Detection

Configure Git

Initialize Git

Run the Project

Next Steps

References

OCaml Modules & Libraries (Like JS but Better)

Index

🟣 Use Modules and Libraries

Create a Module

Create a dune File

Register a Library

Use a Library

Run the Project

🟣 Create an Interface File

Run the Project

Add the sub function to the main.ml file

Next Steps

References

Why you should consider OCaml in your toolkit

When Failure is Not an Option: A Practical Case for OCaml

When Failure is Not an Option: A Practical Case for OCaml

Sources

Index

🟣 A New Perspective on Programming

🟣 The Aha Moment

🟣 The Five Pillars of OCaml

🟣 Performance Without Sacrifice

🟣 Correctness with Safety Nets

Thinking in Edge Cases

Making Illegal States Unrepresentable

🟣 Power and Agility

Type Inference That Helps, Not Hinders

🟣 Functional

Everything is an Expression

Functional to the Core

🟣 But Practical

🟣 The Takeaway

🟣 Explore Together

🟣 Next Steps

Practical OCaml

References

Index

Tail Recursion Optimization

Steps to Apply Tail Recursion:

Example: Factorial Function

Non-Tail-Recursive Version:

Tail-Recursive Version:

Explanation:

Alternative Syntax:

Recursive and Parameterized Variants

Error Handling

Option Type

Definition

Usage

Example: Prevent Finding an Element in an Empty List

Summary:

Result Type

Definition

Usage

Example: Throwing an Error Value When Trying to Get the First Element in an Empty List

Example: Throwing an Error Value for Division by Zero

Summary:

Exceptions

Definition

Add the `sub` function to the `main.ml` file

Sequence Operator (`;`)

`unit` Type

`let` Definitions

`let` Definitions Are Immutable

`let` Expressions

`let` Expression Scope

Cons Operator (`::`)

Append Operator (`@`)