(* map, filter, fold{_left, _right} *)

let map f l =
  List.fold_right
    (fun el mapped_rest ->
        (f el)::mapped_rest
    )
    l
    []
    ;;

let map f l =
  List.rev
  (List.fold_left
    (fun mapped_rest el ->
      (f el)::mapped_rest
    )
    []
    l)
;;

let filter (f: 'a -> bool) (l: 'a list) : 'a list =
  List.fold_right
    (fun el filtered_rest ->
      if f el then
        el::filtered_rest
      else
        filtered_rest
    )
  l
  []
;;

type 'a tree = Leaf | Node of 'a * 'a tree * 'a tree;;

let rec tree_map (f: 'a -> 'b) (t: 'a tree) : 'b tree =
  match t with
  | Leaf -> Leaf
  | Node (value, l, r) ->
    Node (f value, tree_map f l, tree_map f r)
;;

let t = Node (1, Node (2, Leaf, Leaf), Node (3, Leaf, Leaf));;

let rec tree_sum (t: int tree): int =
  match t with
  | Leaf -> 0
  | Node (value, l, r) ->
      value + tree_sum l + tree_sum r
  ;;

let rec tree_size (t: 'a tree): int =
    match t with
    | Leaf -> 0
    | Node (_, l, r) ->
        1 + tree_size l + tree_size r
    ;;

let rec tree_fold (f: 'a -> 'b -> 'b -> 'b)
  (t: 'a tree) (b: 'b) : 'b =
    match t with
    | Leaf -> b
    | Node (value, l, r) ->
        f value (tree_fold f l b) (tree_fold f r b)
;;

let tree_sum t =
  tree_fold
    (fun value summed_left summed_right ->
      value + summed_left + summed_right
    )
    t
    0
;;

let tree_size t =
  tree_fold
    (fun value size_of_left size_of_right ->
      1 + size_of_left + size_of_right
    )
    t
    0
;;

let tree_rev t =
  tree_fold
    (fun value reversed_left reversed_right ->
      Node (value, reversed_right, reversed_left)
    )
    t
    Leaf
;;

let lazy_divide a b =
  raise Division_by_zero
;;

exception My_div_by_zero;;

let my_div a b =
  if b = 0 then raise My_div_by_zero
  else a / b
;;

let my_div2 a b =
  try a / b
  with Division_by_zero ->
    let _ = Printf.printf "oops"
    in 0
    (* Printf.printf "oops"; 0 is syntactic sugar *)
  | My_div_by_zero -> 1
  | _ -> 2
;;

let foo b = my_div 42 b;;

let main () = foo 0;;

let _ = main ();;

(* export OCAMLRUNPARAM="b" *)