(* Чёрч-кодирование пар. *)

let pair =
  fun x -> fun y -> fun projection -> projection x y

let fst =
  fun p -> p (fun x -> fun y -> x)

let snd =
  fun p -> p (fun x -> fun y -> y)

let () =
  let p = pair 3 42 in
  fst p
  |> Printf.printf "fst p: = %i\n"



(* Чёрч-кодирование вариантов. *)

let inl =
  fun x -> fun case_1 -> fun case_2 -> case_1 x

let inr =
  fun x -> fun case_1 -> fun case_2 -> case_2 x

(* Параметр with_ здесь только для вида, чтобы синтаксис в точке использования
   был похож на OCaml. *)
let match_ =
  fun x -> fun with_ -> fun case_1 -> fun case_2 -> x case_1 case_2

let with_ =
  fun x -> x

let _ =
  let x = inr 3 in
  match_ x with_
    (fun y -> y + 1)
    (fun z -> z - 1)
  |> Printf.printf "результат match_: %i\n"

(* Для сравнение, то похожая программа, использующая встроенные варианты
   OCamlа: *)
let _ =
  let x = `Inr 3 in
  (match x with
  | `Inl y -> y + 1
  | `Inr z -> z - 1)
  |> Printf.printf "результат match: %i\n"



(* Чёрч-кодирование bool. *)

(* Мы передаём case_true и case_false ненужную функцию (fun x -> x) только для
   того, чтобы задержать вычисление case_true и case_false. OCaml использует
   строгое вычисление. То есть, каждый аргумент полностью вычисляется перед тем,
   как вызывается фунция. Ниже приведён пример без этого дополнительного
   аргумента. *)
let true_ =
  fun case_true -> fun case_false -> case_true (fun x -> x)

let false_ =
  fun case_true -> fun case_false -> case_false (fun x -> x)

let if_ =
  fun condition -> fun case_true -> fun case_false ->
    condition case_true case_false

let _ =
  if_ true_
    (fun then_ -> print_endline "hello"; 3)
    (fun else_ -> print_endline "world"; 42)
  |> Printf.printf "результат if_: %i\n"

let t_ = fun x -> true_
let f_ = fun x -> false_

let and_ =
    fun p -> fun q -> p (fun x -> q t_ f_) f_

let or_ =
    fun p -> fun q -> p t_ (fun x -> q t_ f_)

let (&&&) = and_
let (|||) = or_

let _ =
    if_ (true_ &&& true_)
        (fun then_ -> "T")
        (fun else_ -> "F")
    |> Printf.printf "T & T = %s\n";;
    if_ (true_ &&& false_)
        (fun then_ -> "T")
        (fun else_ -> "F")
    |> Printf.printf "T & F = %s\n";;
    if_ (false_ &&& true_)
        (fun then_ -> "T")
        (fun else_ -> "F")
    |> Printf.printf "F & T = %s\n";;
    if_ (false_ &&& false_)
        (fun then_ -> "T")
        (fun else_ -> "F")
    |> Printf.printf "F & F = %s\n";;

    if_ (true_ ||| true_)
        (fun then_ -> "T")
        (fun else_ -> "F")
    |> Printf.printf "T | T = %s\n";;
    if_ (true_ ||| false_)
        (fun then_ -> "T")
        (fun else_ -> "F")
    |> Printf.printf "T | F = %s\n";;
    if_ (false_ ||| true_)
        (fun then_ -> "T")
        (fun else_ -> "F")
    |> Printf.printf "F | T = %s\n";;
    if_ (false_ ||| false_)
        (fun then_ -> "T")
        (fun else_ -> "F")
    |> Printf.printf "F | F = %s\n";;

(* Это более стандартное Чёрч-кодирование bool, но оно работает только в языке,
   который не использует строгое вычисление. В OCaml, из-за строго вычисления,
   это кодирование приводит к тому, что оба аргумента к if_lazy, и case_true и
   case_false, полностью вычисляются, что вызывает побочные эффекты обоих,
   несмотря на то, что в итоге только один из них будет выбран. *)

let true_lazy =
  fun case_true -> fun case_false -> case_true

let false_lazy =
  fun case_true -> fun case_false -> case_false

let if_lazy =
  fun condition -> fun case_true -> fun case_false ->
    condition case_true case_false

let _ =
  if_lazy true_lazy
    (print_endline "hello"; 3)
    (print_endline "world"; 42)
  |> Printf.printf "результат if_lazy': %i\n"