=== lambda-bool.ml === Modeling boolean operators as lambda expressions
(* true: Lx.Ly.x *)
let atrue = fun x -> fun y -> x

(* false: Lx.Ly.y *)
let afalse = fun x -> fun y -> y

(* not: Lp.p true false *)
let anot = fun p -> (p afalse atrue)

(* and: La.Lb.a b false *)
let aand = fun a -> fun b -> (a b afalse)

let aor = fun a -> fun b -> (a atrue b)

let axor = fun a -> fun b -> (a (anot b) b)

(* prints true of false from atrue or afalse *)
let aprint x = print_string (x "True\n" "False\n")

let aif = fun a -> fun b -> fun c -> (a b c)
;;

print_string "not True: ";;
aprint ( anot atrue );;

print_string "not False: ";;
aprint ( anot afalse );;

print_string "True and False: ";;
aprint ( aand atrue afalse );;

print_string "True and True: ";;
aprint ( aand atrue atrue );;

print_string "True or False: ";;
aprint ( aor atrue afalse );;

print_string "True xor True: ";;
aprint ( axor atrue atrue );;

print_string "if true 1 else 2: ";;
print_int (aif atrue 1 2);;
print_newline ();;

print_string "if false 1 else 2: ";;
print_int (aif afalse 1 2);;
print_newline ();;

=== lambda-int.ml === modeling natural numbers as lambda expressions
(* zero: Lx.Ly.y (same as false)*)
let zero = fun x -> fun y -> y

let succ = fun z -> fun x -> fun y -> (x (z x y))

(* one: Lx.Ly.x y *)
let one = (succ zero)

(* two: Lx.Ly.x (x y) *)
let two = (succ one)

(* recursively creates any number *)
let rec number n =
   if (n=0) then zero
   else (succ (number (n-1)))

(* Prints a number *)
let print_number n = print_int (n ((+) 1) 0);
   print_newline ()

(* adds two numbers *)
let add = fun m -> fun n -> fun f -> fun x -> (m f (n f x))

(* multiplies two numbers *)
let mul = fun m -> fun n -> (m (add n) zero)

(* multiplies two numbers, another solution *)
let mul2 = fun m -> fun n -> fun f -> (m (n f))
;;

print_number zero;;
print_number one;;
print_number two;;
print_number (add one two);;
print_number (number 9);;
print_number (add (number 9) (number 7));;
print_number (mul (number 9) (number 7));;
print_number (mul2 (number 9) (number 7));;

=== lambda-pair === modeling pair operations as lambda expressions

(* true: Lx.Ly.x *)
let atrue = fun x -> fun y -> x

(* false: Lx.Ly.y *)
let afalse = fun x -> fun y -> y

let pair12 = (fun x -> x 1 2)

let fst = (fun x -> x atrue)

let snd = (fun x -> x afalse)
;;

print_int (fst pair12);;
print_newline ();;

print_int (snd pair12);;
print_newline ();;