OCaml Warm-Up

Pattern Matching

Match on AST node types directly. The compiler warns you if you forget a case.

Algebraic Data Types

ASTs, lattice values, and analysis results are all naturally expressed as ADTs.

Type Safety

Strong static types catch bugs at compile time — no null pointer surprises.

Immutability by Default

Functional style means fewer side effects, easier reasoning about program state.

Module System

Signatures + functors let you write generic analyses parameterized by abstract domains.

Tooling

ocamllex and Menhir provide industrial-strength lexer/parser generators.

Top-level bindings

(* Immutable binding *)
let x = 42

(* Function with type annotations *)
let square (n : int) : int = n * n

(* Multiple arguments *)
let add (a : int) (b : int) : int = a + b

Local bindings with let...in

let hypotenuse a b =
  let a2 = a *. a in
  let b2 = b *. b in
  Float.sqrt (a2 +. b2)

If / then / else (expression, not statement)

let abs x =
  if x >= 0 then x else -x

(* Returns a value -- no "return" keyword *)
let classify n =
  if n > 0 then "positive"
  else if n < 0 then "negative"
  else "zero"

Key idea

Everything is an expression that produces a value. There are no statements.

Tuples — lightweight grouping

(* A position is (line, column) *)
type pos = int * int

let origin : pos = (1, 1)

(* Destructure in function args *)
let format_pos ((line, col) : pos) : string =
  Printf.sprintf "line %d, col %d" line col

(* Pattern match *)
let advance_pos (line, col) c =
  if c = '\n' then (line + 1, 1)
  else (line, col + 1)

Tuples are positional — access by pattern matching, not by name.

Records — named fields

type assignment = {
  var_name : string;
  value    : int;
  line     : int;
}

let a = { var_name = "x"; value = 5; line = 1 }

(* Field access *)
let name = a.var_name

(* Functional update -- creates a NEW record *)
let a' = { a with value = a.value + 3 }

Records are immutable by default. Use { r with field = new_val } to "update".

Defining variants

(* Binary operators *)
type op = Add | Sub | Mul

(* Expression tree -- a mini AST *)
type expr =
  | Num of int
  | Var of string
  | BinOp of op * expr * expr

Each variant is a constructor that tags the data it carries.

Building values

(* 2 + 3 *)
let e1 = BinOp (Add, Num 2, Num 3)

(* x * (1 + y) *)
let e2 = BinOp (Mul, Var "x",
            BinOp (Add, Num 1, Var "y"))

Basic matching

let string_of_op o =
  match o with
  | Add -> "+"
  | Sub -> "-"
  | Mul -> "*"

Recursive matching on trees

let rec string_of_expr e =
  match e with
  | Num n -> string_of_int n
  | Var x -> x
  | BinOp (o, l, r) ->
    Printf.sprintf "(%s %s %s)"
      (string_of_expr l)
      (string_of_op o)
      (string_of_expr r)

Exhaustiveness checking

(* If you forget a case: *)
let bad o = match o with
  | Add -> "+"
  | Sub -> "-"
(* Warning 8: this pattern-matching
   is not exhaustive.
   Here is an example of a case
   that is not matched: Mul *)

Matching on tuples

let classify (x, y) = match (x, y) with
  | (0, 0) -> "origin"
  | (0, _) -> "y-axis"
  | (_, 0) -> "x-axis"
  | _      -> "other"

Recursive functions with let rec

(* Count nodes in an expression tree *)
let rec count_nodes e =
  match e with
  | Num _ | Var _ -> 1
  | BinOp (_, l, r) ->
    1 + count_nodes l + count_nodes r

(* Tree depth *)
let rec depth e =
  match e with
  | Num _ | Var _ -> 1
  | BinOp (_, l, r) ->
    1 + max (depth l) (depth r)

Option: safe "nullable" values

(* Option type: Some x or None *)
type 'a option = Some of 'a | None

(* Evaluate if no variables present *)
let rec eval e =
  match e with
  | Num n -> Some n
  | Var _ -> None  (* can't evaluate *)
  | BinOp (o, l, r) ->
    match eval l, eval r with
    | Some a, Some b ->
      Some (apply_op o a b)
    | _ -> None

List basics

(* Immutable linked lists *)
let xs = [1; 2; 3; 4; 5]
let ys = 0 :: xs  (* prepend: [0;1;2;3;4;5] *)

(* Pattern match on lists *)
let rec length = function
  | [] -> 0
  | _ :: rest -> 1 + length rest

List.map — transform each element

let double_all xs = List.map (fun x -> x * 2) xs
(* double_all [1;2;3] = [2;4;6] *)

List.filter — keep matching elements

let keep_positive xs =
  List.filter (fun x -> x > 0) xs
(* keep_positive [-1;3;0;5] = [3;5] *)

List.fold_left — reduce to a single value

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

StringMap — variable environments

module StringMap = Map.Make(String)

(* Build from a list of pairs *)
let build_env pairs =
  List.fold_left
    (fun env (k, v) -> StringMap.add k v env)
    StringMap.empty
    pairs

(* Lookup with Option *)
let lookup env name =
  StringMap.find_opt name env

(* Get all keys *)
let all_vars env =
  List.map fst (StringMap.bindings env)

StringSet — variable sets

module StringSet = Set.Make(String)

let s1 = StringSet.of_list ["x"; "y"; "z"]
let s2 = StringSet.of_list ["y"; "z"; "w"]

(* Set operations *)
let union = StringSet.union s1 s2
let inter = StringSet.inter s1 s2
let diff  = StringSet.diff s1 s2

(* Convert to list *)
StringSet.elements inter  (* ["y"; "z"] *)

Records in practice

type assignment = {
  var_name : string;
  value    : int;
  line     : int;
}

let a = { var_name="x"; value=5; line=1 }

(* Format for display *)
let format_assign a =
  Printf.sprintf "%s = %d (line %d)"
    a.var_name a.value a.line

(* Functional update *)
let increment_value a n =
  { a with value = a.value + n }

Mutable state with ref

(* ref creates a mutable cell *)
let counter = ref 0

(* Read with ! *)
let current = !counter     (* 0 *)

(* Write with := *)
counter := !counter + 1    (* now 1 *)

(* Closure over a ref -- a counter factory *)
let make_counter () =
  let n = ref 0 in
  fun () ->
    let v = !n in
    n := v + 1;
    v

let next = make_counter ()
(* next() = 0, next() = 1, next() = 2 *)

Signature (module type)

module type LATTICE = sig
  type t
  val bottom : t
  val top : t
  val join : t -> t -> t
  val equal : t -> t -> bool
  val to_string : t -> string
end

The signature says what exists. The type t is abstract — callers cannot see its representation.

Structure (module)

module BoolLattice : LATTICE
  with type t = bool
= struct
  type t = bool
  let bottom = false
  let top = true
  let join a b = a || b
  let equal a b = (a = b)
  let to_string b =
    if b then "true" else "false"
end

The with type t = bool makes the type transparent so callers can pass true/false directly.

ThreeValueLattice

type three_value =
  | Bot | Zero | Positive | Unknown

module ThreeValueLattice
  : LATTICE with type t = three_value
= struct
  type t = three_value
  let bottom = Bot
  let top = Unknown
  let join a b =
    if a = b then a
    else if a = Bot then b
    else if b = Bot then a
    else Unknown
  let equal a b = (a = b)
  let to_string = function
    | Bot -> "Bot" | Zero -> "Zero"
    | Positive -> "Positive"
    | Unknown -> "Unknown"
end

Why lattices?

Every abstract domain in program analysis forms a lattice:

• Bottom = no information / unreachable
• Top = could be anything / no precision
• Join = merge information from two paths

ocamllex — lexer (.mll files)

let digit = ['0'-'9']
let alpha = ['a'-'z' 'A'-'Z' '_']

rule token = parse
  | [' ' '\t' '\n']+  { token lexbuf }
  | '+'               { PLUS }
  | '-'               { MINUS }
  | digit+ as n       { INT (int_of_string n) }
  | alpha+ as id      { IDENT id }
  | eof               { EOF }

Menhir — parser (.mly files)

%token <int> INT
%token <string> IDENT
%token PLUS MINUS STAR SLASH
%left PLUS MINUS    (* precedence *)
%left STAR SLASH

%%
program: e=expr EOF  { e } ;

expr:
  | e1=expr PLUS e2=expr
      { BinOp(Add, e1, e2) }
  | a=atom  { a } ;

atom:
  | n=INT   { Num n }
  | id=IDENT { Var id } ;

The ambiguity problem

How should 3 + 4 * 2 be parsed?

We want Option B (standard math precedence).

Declarations (lowest to highest)

%left PLUS MINUS       (* lowest *)
%left STAR SLASH       (* higher *)
%nonassoc UMINUS       (* highest *)

• %left — left-associative: a-b-c = (a-b)-c
• %right — right-associative
• %nonassoc — cannot chain

Unary minus trick

atom:
  | MINUS a=atom %prec UMINUS
      { Neg a }
  ;

%prec UMINUS tells Menhir to use the highest precedence for this rule.

Language Fundamentals

• Everything is an expression — no statements, no null, no void
• Immutable by default — use ref only when needed
• Pattern matching is your primary control flow tool
• Type inference means annotations are optional but helpful

Data Structures

• ADTs for ASTs and abstract domain values
• StringMap for variable environments
• StringSet for tracking variable sets
• Records for structured data with named fields

Module System

• Signatures define interfaces (like Java interfaces)
• Structures provide implementations
• Functors parameterize modules over other modules
• The LATTICE + MakeEnv pattern recurs throughout the bootcamp

Parsing

• ocamllex for lexing (regex-based tokenization)
• Menhir for parsing (grammar rules producing AST nodes)
• Precedence declarations resolve ambiguity

What you will learn

• What is program analysis and why do we need it?
• Static vs. dynamic analysis trade-offs
• Soundness and completeness
• The lattice-theoretic foundation of abstract interpretation
• Fixpoint computation and the widening operator

How Module 0 prepared you