(* Last time *)
let add1_to_all l = List.map ((+) 1) l
let add1_to_all = List.map ((+) 1);;
let double_all = List.map (( *) 2);;
let pair_all = 
  let pair x = (x, x) in
  List.map pair
;;
let pair_all = List.map (fun x -> (x, x));;

let only_odds = List.filter (fun x -> x mod 2 <> 0);;

(* Fold / reduce *)

let rec sum (l: int list) : int =
  match l with
  | [] -> 0
  | h::t -> h + sum t
;;

let rec length (l: 'a list) : int =
  match l with
  | [] -> 0
  | h::t -> 1 + length t
;;

let rec repeat (l: 'a list) : 'a list =
  match l with
  | [] -> []
  | h::t -> h::h::(repeat t)
;;

(* What we return in base case *)
(* What we do in the cons case *)

let rec fold_right (f: 'a -> 'b -> 'b) 
    (l: 'a list) (b: 'b) : 'b =
  match l with
  | [] -> b
  | h::t -> f h (fold_right f t b)
;;

let sum l = fold_right (+) l 0;;
let length l =
  fold_right
   (fun x r -> 1 + r)
   l
   0;;
let repeat l =
  fold_right
    (fun x r -> x::x::r)
    l
    []
;;

let mystery l = fold_right (fun x r -> x::r) l [];;

let sum_tr (l: int list) : int =
  let rec sum_tr_helper a l =
    match l with
    | [] -> a
    | h::t -> sum_tr_helper (a + h) t
  in sum_tr_helper 0 l
;;

let length_tr (l: 'a list) : int =
  let rec length_tr_helper a l =
    match l with
    | [] -> a
    | h::t -> length_tr_helper (a + 1) t
  in length_tr_helper 0 l
;;

let rec fold_left (f: 'b -> 'a -> 'b) (b: 'b)
  (l: 'a list) =
  match l with
  | [] -> b
  | h::t -> fold_left f (f b h) t
;;

let sum_tr l = fold_left (+) 0 l;;
let length_tr l = fold_left (fun r x -> r + 1) 0 l;;

let mystery2 l = fold_left (fun r x -> x::r) [] l;;

let max (l: 'a list) : 'a option =
  List.fold_left
    (fun (max_so_far_opt: 'a option) (x: 'a) ->
      match max_so_far_opt with
      | None -> Some x
      | Some max_so_far ->
        if x > max_so_far then
          Some x
        else
          max_so_far_opt
      )
    None
    l
;;

let partition (pivot: int) (l: int list) :
  (int list) * (int list) =
  List.fold_right
    (fun elt (list_le, list_gt) -> 
      if elt <= pivot then
        (elt::list_le, list_gt)
      else
        (list_le, elt::list_gt)
    )
    l
    ([], [])
      ;;

let partition (pivot: int) (l: int list) :
      (int list) * (int list) =
      let (list_le, list_gt) =
      List.fold_left
        (fun (list_le, list_gt) elt -> 
          if elt <= pivot then
            (elt::list_le, list_gt)
          else
            (list_le, elt::list_gt)
        )
        ([], [])
        l
      in (List.rev list_le, List.rev list_gt)
;;