An Invitation to OCaml

Sudha Parimala
sudha [at] tarides [dot] com
Tarides

What is OCaml?

OCaml is an industrial strength functional programming language

What is OCaml?

OCaml is an industrial strength functional programming language

• Derived from "ML" (Meta-language)
• Supports imperative and Object oriented programming

What is functional programming?

• Functions are treated as first class citizens - inspired from Lambda Calculus.
• LISP - first FP language by John McCarthy
• Haskell, Scheme, Clojure etc.

Why OCaml?

Programming languages matter!

A Language that doesn’t affect the way you think about programming, is not worth knowing!
-Alan Perils

Functional Programming is visionary!

Why OCaml?

Who are we writing programs for?

• Machines ❌
• Humans ✔️

Why OCaml?

Who are we writing programs for?

• Machines ❌
• Humans ✔️

OCaml lets you write elegant programs!

Notable features

• Immutability
• Algebraic Data Types and Pattern matching
• Higher order functions
• Type inference
• Systems Programming
• Garbage collection

Immutability

• Variables don't vary
• No side effects

Length of a list

Python

length = 0

for i in test_list:
    length = length + 1

print (length)

Length of a list

OCaml

let rec length list =
    match list with
    | [] -> 0
    | x :: xs -> 1 + length list

val length : 'a list -> int = <fun>

Rich Type System

Base types

• int
• float
• string
• …

Rich Type System

Sum Types

type day = Sun | Mon | Tue | Wed | Thu | Fri | Sat

Algebraic Data Types

type 'a tree = Empty
  | Node of 'a * 'a tree * 'a tree

let rec preorder f = function
    Empty        -> ()
  | Node (v,l,r) -> f v;
                    preorder f l;
                    preorder f r

Algebraic Data Types

let rec inorder f = function
    Empty        -> ()
  | Node (v,l,r) -> inorder f l;
                    f v;
                    inorder f r

let rec postorder f = function
    Empty        -> ()
  | Node (v,l,r) -> postorder f l;
                    postorder f r;
                    f v

Higher Order Functions

• Functions are like values
  • you can pass it around as arguments

Higher Order Functions

• Functions are like values
  • you can pass it around as arguments

let multiply x y = x * y

let double = multiply 2 

let four = double 2

Higher Order Functions

• Functions are composable
• Compasability improves code reusability

let compose f g x = f (g x)

let double x = 2 * x
let square x = x * x

let double_then_square = compose double square

Garbage Collection

• OCaml comes with a generational incremental collector
• Large major heap
  • Collection done in slices, low pausetimes
• Small minor heap
  • Fast allocation and collection
• Multicore capable GC
  • Every thread has its own minor heap

Systems programming

• Support for efficient Unix programming
• Higly performant C FFI
• ML type system -> better type safety with same performance

Open Source Projects

Coq

ReasonML

Multicore OCaml (OCaml 5)

• Adds native support for shared memory parallelism and concurrency.
• Concurrency: Overlapped computations
• Parallelism: Simultaneous computations

Multicore OCaml (OCaml 5)

• History
  • Started in 2014 at University of Cambridge.
  • Developed at OCaml Labs, IIT Madras, Tarides.
  • Released in Dec 2022.
• Major challenges
  • Development of a Multicore Garbage collector.
  • Backwards compatibility.

Multicore OCaml

• Domains are the fundamental unit of parallelism.
  • Mapped 1:1 to OS threads
  • A new domain runs in parallel with its calling domain
  • Spawn/join, Atomic operations, Local-storage
• Effect Handlers
  • Programming with user-defined effects
  • Non-local control-flow for concurrency