stdlib.ffl

# general

def compose
  :: (b -> c) -> (a -> b) -> (a -> c)
  = \f g e -> f (g e)

newop . of Right 9 compose

def flip
  :: (a -> b -> c) -> (b -> a -> c)
  = \f a b -> f b a

data Compare = Lt | Eq | Gt

def int_cmp
  :: (Int -> Int -> Compare)
  = \a b -> if a == b then Eq else if a < b then Lt else Gt

# List

data List a =
    Cons a (List a)
  | Empty

def head
  :: (List a) -> a
  = \match
      Cons a _  -> a
    | Empty     -> undefined

def tail
  :: (List a) -> List a
  = \match
      Cons _ a  -> a
    | Empty     -> undefined

def empty
  :: (List a) -> Bool
  = \match
      Cons _ _  -> False
    | Empty     -> True

def foldr
  :: (a -> b -> b) -> b -> (List a) -> b
  = \fun st li -> rec
    foldr_impl = \match
        Cons hd tl  -> fun hd $ foldr_impl tl
      | Empty       -> st
    in foldr_impl li

def foldl
  :: (b -> a -> b) -> b -> (List a) -> b
  = \fun acc li -> rec
    foldl_impl = \acc -> \match
        Cons hd tl  -> foldl_impl (fun acc hd) tl
      | Empty       -> acc
    in foldl_impl acc li

def map
  :: (a -> b) -> (List a) -> (List b)
  = \fun li -> rec
    map_impl = \match
        Cons hd tl  -> Cons (fun hd) (map_impl tl)
      | Empty       -> Empty
    in map_impl li

def zip
  :: (a -> b -> c) -> (List a) -> (List b) -> (List c)
  = \fun l1 l2 -> rec
    zip_impl = \l1 l2 ->
      if (not . empty) l1 && (not . empty) l2
      then Cons (fun (head l1) (head l2)) $ zip_impl (tail l1) (tail l2)
      else Empty
    in zip_impl l1 l2

def take
  :: Int -> (List a) -> List a
  = \n l ->
    if n <= 0 || empty l
    then Empty
    else Cons (head l) (take (n-1) (tail l))

def drop
  :: Int -> (List a) -> List a
  = \n l ->
    if n <= 0 || empty l
    then l
    else drop (n-1) (tail l)