Files
reference/source/_posts/ocaml.md
T
2024-08-11 21:40:54 -06:00

6.5 KiB

title, date, background, tags, categories, intro, plugins
title date background tags categories intro plugins
OCaml 2024-08-06 00:00:00 bg-[#ec670f]
scientific
functional
Programming
The [OCaml](https://www.ocaml.org/) cheat sheet is a one-page reference sheet for the OCaml programming language.
copyCode

Getting Started

hello.ml

# let () =
    let message = "Hello, World!" in
    Printf.printf "%s\n" message

Compile and Run

$ ocamlc -o hello.byte hello.ml
$ ./hello.byte

Build and Run with Dune

$ dune build hello.exe
$ _build/default/hello.exe

See the dune documentation for more info.

Imports

Install modules with opam

$ opam install hex

Global Open

# open Hex 

Local Open

# Hex.of_string "hex string" 

# let open Hex in 
   of_string "to hex"

Comments

Line & Block Comments

(* A single line comment *)

(* A multi-line comment
* where we want to explain 
* something complex *)

(* Outer comment
   (* Nested comment *)
   End of outer comment *)

Documentation Comments

val sum : int -> int -> int
(** [sum x y] returns the sum
 of two integers [x] and [y] *)

Data Types

Predefined Types

Unit

# () (* eqivalent to void *)
- : unit = ()

Basic Types

# 5 (* int *)
# 3.14 (* float *)

# true (* bool *)
# false

# 'a' (* char *)
# "a string" (* string *)

# String.to_bytes "hello" (* bytes *)
- : bytes = Bytes.of_string "hello"

# (3, 5) (* tuple *)

# ref 0 (* reference *)

Options & Results

# Some 42
- : int option = Some 42

# Ok 42

# Error "404"

Arrays & Lists

Arrays

# [|0; 1; 2; 3|] 

# [|'u'; 's'; 'c'|].(1) (* array access *)
- char = 's'

Arrays are mutable

# let scores = [|97; 85; 99|]
# scores.(2) <- 89 (* update an element *)
- unit = ()

# scores
- : int array = [|97; 85; 89|]

Lists

# [1; 2; 3]
- : int list = [1; 2; 3;]

# ["a"; "str"; "lst"]
- : string list = ["a"; "str"; "lst"]

Lists are immutable

# let lst = [1; 2; 3]

# let new_lst =  lst :: 4 (* append to a new list *)
- : int list = [1; 2; 3; 4]

User-Defined Types

Records

Bundle related data

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

# let zeno = {name = "Zeno"; age = 30};;
val zeno : person = {name = "Zeno"; age = 30}

Variants

Several different, but related types

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

let my_shape = Circle 5.0
- : shape = Circle 5.

Aliases

Provide meaningful name to complex or commonly used types

# type point = float * float

# let origin: point = (0.0, 0.0)
val origin : point = (0., 0.)

Functions

Functions

Single parameter

# let add_one x = 
    let result = x + 1 in
    result

# add_one 1
- : int = 2

Multiple parameters

# let sum x y =
    let result = x + y in
    result

# sum 1 2
- : int = 3

Tuple parameter

# let str_concat (x, y) =
    x ^ " " ^ y 

# str_concat ("Hello", "OCaml")
- : string = "Hello Ocaml"  

Recursive Functions

rec

All recusive functions use the rec keyword

# let rec factorial n = 
    if n < 1 then 1 else n * factorial (n - 1)

The above is not very efficient and can cause stackoverflow.

Tail Recursion

Makes use of a helper function and the acc argument.

# let rec factorial_helper n acc = 
    if n = 0 then acc
    else factorial_helper (n - 1) (n * acc)

Notice the last call is the recursive function.

# let factorial n = factorial_helper n 1

Chaining

Application Operator

Read from right to left the first operation is sum 2 3

(* find log(2 + 3) *)
# log @@ float_of_int @@ sum 2 3 
- : float = 1.609...

Pipeline

(* find log((x + y)!) *)
# sum 2 3 
  |> factorial
  |> float_of_int
  |> log
- : float = 4.787...

|> takes the output of the function and passes it as input to the next function in the pipeline

Control Flow

If Statements

If Statement

# let is_pos x = 
    if x > 0 then "positive" else "negative"

If else if

# let f x = 
    if x > 3 then "gt 3"
    else if x < 3 then "lt 3"
    else "eq 3"

Pattern Matching

let is_pos x = 
  match x > 0 with 
  | true  -> "positive"
  | false -> "negative"

Loops

For loop

for i = 1 to 5
 do print_int i 
done

While loop

Notice the ref is needed to update the while condition.

let i = ref 0 in 
  while !i < 5 do
    print_int !i;
    i := !i + 1
done

Operators

Comparison Operators

=         (* equal to *)
<> or !=  (* not equal to *)
>         (* greater than *)
<         (* less than *)
>=        (* greater than or eq to *)
<=        (* less than or eq to *)

Arithmatic Operators

(* int operator   float operator *)
+                 +.  (* addition *) 
-                 -.  (* subtraction *)
*                 *.  (* multiplication *)
/                 /.  (* division *)
                  **  (* power *)

Useful Tools

List

Searching & Filtering

# let lst = [1;2;3]

# List.filter (fun x -> x mod 2 = 0) lst

# List.find (fun x -> x = 4) lst
Exception: Not_found

# List.sort compare [2; 1; 3]
- : int list = [1; 2; 3]

Applying Transformations

(* Loop over list and apply fun f *)
# List.iter f lst

(* map a function to each elem *)
# List.map (fun x -> x + x) lst
- : int list = [2; 4; 6]

(* Apply an operator between elements *)
(* Ex. 1 + 2 + 3 *)
# let sum = List.fold_left ( + ) 0 
# sum lst 

Associaton Lists

Definition and Access

# let scores = 
    [("math", 91); ("phil", 89); ("stats", 94)]

# List.assoc "stats" scores;;
- : int = 94

# List.mem_assoc "math" scores
- : bool = true

Split and Combine

# List.split scores
- : string list * int list = (["math"; "phil"; "stats"], [91; 89; 94])

# List.combine [1;2;3] [4; 5; 6]
- : (int * int) list = [(1, 4); (2, 5); (3, 6)]

Association lists are similar to dictionaries or hashmaps

Hash Tables

Initialize & Add Data


# let my_htable = Hashtbl.create 3
val my_htable : ('_weak1, '_weak2) Hashtbl.t = <abstr>

# Hashtbl.add my_htable "A" "John";
  Hashtbl.add my_htable "A" "Jane";
  Hashtbl.add my_htable "B" "Max";;

Find Data

# Hashtbl.find my_htable "A"
- : string = "Jane"

(* find all *)
# Hashtbl.find_all my_htable "A"
- : string list = ["Jane"; "John"]