-- -- Expresso Prelude -- type Maybe a = ; type Either a b = ; let id = x -> x; const = x y -> x; flip = f x y -> (f y x); ---------------------------------------------------------------- -- Basic list operations foldr = f z -> fix (r xs -> case uncons xs of { Nothing{} -> z , Just {head, tail} -> f head (r tail) }); null = xs -> case uncons xs of { Nothing{} -> True, Just{} -> False }; map = f -> foldr (x xs -> f x :: xs) []; filter = f -> foldr (x xs -> if f x then (x::xs) else xs); length = foldr (const (n -> 1 + n)) 0; foldl = f z xs -> foldr (x xsf r -> xsf (f r x)) id xs z; concat = xss -> foldr (xs ys -> xs ++ ys) [] xss; ---------------------------------------------------------------- -- Maybe operations - smart constructors create closed variants just : forall a. a -> Maybe a = x -> Just x; nothing : forall a. Maybe a = Nothing{}; maybe : forall a b. b -> (a -> b) -> Maybe a -> b = b f m -> case m of { Just a -> f a, Nothing{} -> b }; isJust = maybe False (const True); isNothing = maybe True (const False); fromMaybe = x -> maybe x id; listToMaybe = foldr (x -> const (just x)) nothing; maybeToList = maybe [] (x -> [x]); catMaybes = xs -> concat (map maybeToList xs); mapMaybe = f -> maybe nothing (just << f); ---------------------------------------------------------------- -- Either operations - smart constructors create closed variants left : forall a b. a -> Either a b = x -> Left x; right : forall a b. b -> Either a b = x -> Right x; either : forall a b c. (a -> c) -> (b -> c) -> Either a b -> c = f g m -> case m of { Left a -> f a, Right b -> g b }; ---------------------------------------------------------------- -- Logical operations and = foldr (x y -> x && y) True; or = foldr (x y -> x || y) False; any = p -> or << map p; all = p -> and << map p; elem = x -> any (x' -> x' == x); notElem = x -> all (x' -> x' /= x); ---------------------------------------------------------------- -- Dynamic binding withOverride = overrides f self -> overrides (f self); mkOverridable = f -> { override_ = overrides -> (withOverride overrides f) | fix f}; override = r overrides -> mkOverridable (r.override_ overrides) -- Exports in { id , const , foldr , null , map , filter , length , foldl , concat , just , nothing , maybe , isJust , isNothing , fromMaybe , listToMaybe , maybeToList , catMaybes , mapMaybe , left , right , either , and , or , any , all , elem , notElem , mkOverridable , override }