Write You a Haskell Stephen Diehl

Syntax Name Kind Description
(,) Pair * -> * -> * 2-Tuple
() Unit * Unit type
(->) Arrow * -> * -> * Arrow type
Bool Bool * Boolean
IO IO * -> * IO Monad
Traversals
Bottom-up traversals and rewrites in a monadic context are so that common that we’d like to automate
this process so that we don’t have duplicate the same logic across all our code. So we’ll write several
generic traversal functions.
descendM :: (Monad m, Applicative m) => (Expr -> m Expr) -> Expr -> m Expr
descendM f e = case e of
EApp a b -> EApp descendM f a descendM f b
EVar a -> EVar pure a
ELam a b -> ELam pure a descendM f b
ELit n -> ELit pure n
ELet n a b -> ELet pure n descendM f a descendM f b
EIf a b c -> EIf descendM f a descendM f b descendM f c
ECase a xs -> ECase f a traverse (descendCaseM f) xs
EAnn a t -> EAnn descendM f a pure t
EFail -> pure EFail
descendCaseM :: (Monad m, Applicative m) => (Expr -> m Expr) -> Match -> m Match
descendCaseM f e = case e of
Match ps a -> Match pure ps descendM f a
e case where the monad is Identity simply corresponds to a pure expression rewrite.
descend :: (Expr -> Expr) -> Expr -> Expr
descend f ex = runIdentity (descendM (return . f) ex)
For example a transformation for use in this framework of traversals might just use pattern matching
to match specific syntactic structure and rewrite it or simply yield the input and traverse to the next
element in the bottom-up traversal.
A pure trnasformation that rewrites all variables named “a” to “b” might be written concisely as the
following higher order function.
transform :: Expr -> Expr
transform = descend f
125