OCaml

• best read from right to left

  int list list (* "a list of list of integers" *)
  

• can be open locally

  let average x y = let open Int64 in (x + y) / of_int 2
  let average x y = Int64((x + y) / of_int 2)
  

• local let module shortcut

  let print_median m =
    let module C = Counter in
    match m with
    | C.Median string -> printf "%s" string
    | C.Before_and_after (before, after) -> printf "%s %s\n" before after
  

• new type

  module type ID = sig
    type t
    val of_string : string -> t
  end
  

• new struct

  module String_id = struct
    type t = string
    let of_string x = x
  end
  

• join?? type+struct into one type

  module M : sig
    type t
  end = struct
    type t = string
  end
  

• join?? type+struct into a several types

  module Username : ID = String_id
  module Hostname : ID = String_id
  

• include, to extend a "class" adding new values on a new module type

  module newM = struct
    include otherM
    let f x = m
  end
  

• guide https://www.cs.cornell.edu/courses/cs3110/2016fa/handouts/style.html
• Modules
• variables, functions, recordtypes

let plusone x = x + 1
let plusone = (fun x -> x + 1) (* lambda *)
let plusone = ( + ) 1 (* partial application *)

signatures (.mli)

open Base
type t
val empty : t
val to_list : t -> (string * int) list
type touch : t -> string -> t

one of the possible implementations for that signature

open Base
type t = (string * int) list
let empty = []
let to_list x = x
let touch counts line =
  let count =
    match List.Assoc.find ~equal:String.equal counts line with
    | None   -> 0
    | Some x -> x
  in
  List.Assoc.add ~equal:String.equal counts line (count + 1)

rec + function + as + when (guard)

let rec destutter list = function
  | [] | [_] as l -> l
  | hd :: (hd' :: _ as tl) when hd = hd' -> destutter tl
  | hd :: tl -> hd :: destutter tl

Function parameters are patterns too

type point = float * float

let distance ((x1,y1):point) ((x2,y2):point) : float =
  let square x = x *. x in
  sqrt (square (x -. x1) +. square (y2 -. y1))

• _exn denotes functions that return an exception
• assert false can be used on a branch that isn't suppose to happen
• optional type annotation
• type variables support for parametric polymorphism
• implicit match of an invisible last argument when using function
• lexically scoped (with let)
• optional arguments
  • begin with ?
    • ?sep ?(sep="")
    • ~sep:":"
  • passed as Option
  • useful when is a wrapper to another function that takes an optional
• labeled arguments (ME: aka keyword args)
  • at any position of arguments
  • defining: ~num
  • passing arguments
    • ~num:3
    • ~num - with label punning if a variable with the same name exists
    • ~f:String:Length
  • when is unclear just from the type signature
    • booleans
    • more than one value of the same type

• Declaring an infix operator

  let ( <^> ) x y = max x y
      in 1 <^> 2
  

• default polymorphic operators considered problematic
• String.concat vs ^
  • .concat allocates 1 string
  • ^ allocates a new string every time it runs
• ( * ) is preferred over (*) for writting operators as functions

https://v2.ocaml.org/manual/stdlib.html

• 5.0 (2022)
  • https://github.com/ocaml-multicore/awesome-multicore-ocaml
  • https://v2.ocaml.org/releases/5.0/manual/parallelism.html
  • https://v2.ocaml.org/releases/5.0/manual/effects.html