type 'a t =
    F :
      { init : unit -> 's
      ; cond : 's -> bool
      ; step : 's -> ('a -> unit) -> unit
      ; freeze : 's -> 'a t } -> 'a t

let[@inline] fold  ~init ~f (F t)=
  let s = t.init () in
  let acc = ref init in
  while t.cond s do
    t.step s (fun a -> acc := f !acc a)
  done;
  !acc

let[@inline] rec of_array a ~i =
  let[@inline] init () = ref i in
  let[@inline] cond s = !s < Array.length a in
  let[@inline] step s f = f a.(!s); incr s in
  let[@inline] freeze s = of_array a ~i:!s in
  F { init; cond; step; freeze }

let of_array = of_array ~i:0

let[@inline] rec map ~f t =
  match t with
  | F t ->
    let[@inline] step s g = t.step s ((fun a -> g (f a)) [@inline]) in
    F { step;
        init = t.init;
        cond = t.cond;
        freeze = fun s -> (map[@inlined never]) ~f (t.freeze s)
      }

let[@inline] filter t ~f =
  match t with
  | F t ->
    let[@inline] step s g = t.step s ((fun a -> if f a then g a) [@inline]) in
    F { t with step }

let main a =
  of_array a
  |> map ~f:((+) 1)
  |> filter ~f:(fun x -> x mod 2 = 0)
  |> fold ~init:0 ~f:(+)