Chapter 8  Language extensions

 let ( let* ) o f =
   match o with
   | None -> None
   | Some x -> f x

 let return x = Some x
val ( let* ) : 'a option -> ('a -> 'b option) -> 'b option = <fun>
val return : 'a -> 'a option = <fun>

 let find_and_sum tbl k1 k2 =
   let* x1 = Hashtbl.find_opt tbl k1 in
   let* x2 = Hashtbl.find_opt tbl k2 in
     return (x1 + x2)
val find_and_sum : ('a, int) Hashtbl.t -> 'a -> 'a -> int option = <fun>

 let find_and_sum tbl k1 k2 =
   ( let* ) (Hashtbl.find_opt tbl k1)
     (fun x1 ->
        ( let* ) (Hashtbl.find_opt tbl k2)
          (fun x2 -> return (x1 + x2)))
val find_and_sum : ('a, int) Hashtbl.t -> 'a -> 'a -> int option = <fun>

 module ZipSeq = struct

   type 'a t = 'a Seq.t

   open Seq

   let rec return x =
     fun () -> Cons(x, return x)

   let rec prod a b =
     fun () ->
       match a (), b () with
       | Nil, _ | _, Nil -> Nil
       | Cons(x, a), Cons(y, b) -> Cons((x, y), prod a b)

   let ( let+ ) f s = map s f
   let ( and+ ) a b = prod a b

 end
module ZipSeq :
  sig
    type 'a t = 'a Seq.t
    val return : 'a -> 'a Seq.t
    val prod : 'a Seq.t -> 'b Seq.t -> ('a * 'b) Seq.t
    val ( let+ ) : 'a Seq.t -> ('a -> 'b) -> 'b Seq.t
    val ( and+ ) : 'a Seq.t -> 'b Seq.t -> ('a * 'b) Seq.t
  end

 open ZipSeq
 let sum3 z1 z2 z3 =
   let+ x1 = z1
   and+ x2 = z2
   and+ x3 = z3 in
     x1 + x2 + x3
val sum3 : int Seq.t -> int Seq.t -> int Seq.t -> int Seq.t = <fun>

 open ZipSeq
 let sum3 z1 z2 z3 =
   ( let+ ) (( and+ ) (( and+ ) z1 z2) z3)
     (fun ((x1, x2), x3) -> x1 + x2 + x3)
val sum3 : int Seq.t -> int Seq.t -> int Seq.t -> int Seq.t = <fun>

 module type Applicative_syntax = sig
   type 'a t
   val ( let+ ) : 'a t -> ('a -> 'b) -> 'b t
   val ( and+ ): 'a t -> 'b t -> ('a * 'b) t
 end

 module type Monad_syntax = sig
   include Applicative_syntax
   val ( let* ) : 'a t -> ('a -> 'b t) -> 'b t
   val ( and* ): 'a t -> 'b t -> ('a * 'b) t
 end