(let discard
  (fn a T Nil ())
)

(let if
  (fn (cond iftrue iffalse) (Bool T T) T
    (case cond
      (true iftrue)
      (_ iffalse))
  )
)


(let ++
  (fn x Int Int
    (+ x 1)
  )
)


(let --
  (fn x Int Int
    (- x 1)
  )
)


(let sum (fix
  (fn sum' ((Vector (Int ...)) -> Int)
           ((Vector (Int ...)) -> Int)
    (fn vec (Vector (Int ...)) Int
      (case vec
        ((h ..t) (+ h (sum' t)))
        (_ 0))
    )
  )
))


(let map-i->i (fix
  (fn map'       (((Vector (Int ...)) (Int -> Int)) -> (Vector (Int ...)))
                 (((Vector (Int ...)) (Int -> Int)) -> (Vector (Int ...)))
    (fn (vec fun) ((Vector (Int ...)) (Int -> Int)) (Vector (Int ...))
      (case vec
      ((h ..t) (<> (vector (fun h)) (map' t fun)))
      (_ (() Int)))
    )
  )
))


(let filter-int (fix
  (fn filter'     (((Vector (Int ...)) (Int -> Bool)) -> (Vector (Int ...)))
                  (((Vector (Int ...)) (Int -> Bool)) -> (Vector (Int ...)))
    (fn (vec pred) ((Vector (Int ...)) (Int -> Bool)) (Vector (Int ...))
      (case vec
        ((h ..t) (
	    if (pred h)
	      (<> (vector h) (filter' t pred))
	      (filter' t pred))
	)
        (_ (() Int))
      )
    )
  )
))


(let repeat
  (fn (fun n) ((Int -> Nil) Int) Nil

    ((let repeat-inner (fix
      (fn repeat-inner'      (((Int -> Nil) Int Int) -> Nil)
                             (((Int -> Nil) Int Int) -> Nil)
        (fn (fun index until) ((Int -> Nil) Int Int)    Nil
	  (case (<= index until)
	    (true (discard (fun index) (repeat-inner' fun (++ index) until)))
            (_ ()))
	)
      )
    ))

    (repeat-inner fun 1 n))
  )
)


(let left-or
  (fn (sum def) ((Sum L R) L) L
    (case sum
      ((inl x) x)
      (_ def))
  )
)


(let right-or
  (fn (sum def) ((Sum L R) R) R
    (case sum
      ((inr x) x)
      (_ def))
  )
)