Data.Functor.Tutorial

Documentation

data AstF t

An example AST type, as an F-algebra. This AST will be used to demonstrate some tricks for composing new data types while maintaining separation of concerns.

This approach was inspired by the recursion-schemes library and the "Data Types a la Carte" paper.

Constructors

RealF Double

ComplexF Double Double

VarF String

AddF t t

MulF t t

AbsF t

Instances

Functor AstF

Methods

fmap :: (a -> b) -> AstF a -> AstF b

(<$) :: a -> AstF b -> AstF a

Eq t => Eq (AstF t)

Methods

(==) :: AstF t -> AstF t -> Bool

(/=) :: AstF t -> AstF t -> Bool

Ord t => Ord (AstF t)

Methods

compare :: AstF t -> AstF t -> Ordering

(<) :: AstF t -> AstF t -> Bool

(<=) :: AstF t -> AstF t -> Bool

(>) :: AstF t -> AstF t -> Bool

(>=) :: AstF t -> AstF t -> Bool

max :: AstF t -> AstF t -> AstF t

min :: AstF t -> AstF t -> AstF t

Pretty t => Pretty (AstF t)

Pretty-printer for ASTs.

Methods

pretty :: AstF t -> String

type Ast = Fix AstF

pattern Add :: Fix AstF -> Fix AstF -> Fix AstF

Patterns to simplify the construction and destructuring of ASTs

pattern Mul :: Fix AstF -> Fix AstF -> Fix AstF

pattern Abs :: Fix AstF -> Fix AstF

pattern Real :: Double -> Fix AstF

pattern Complex :: Double -> Double -> Fix AstF

pattern Var :: String -> Fix AstF

class Pretty a where

A pretty-printing typeclass.

This demonstrates an approach to separation of concerns; the pretty-printer for normal ASTs is implemented independently from the pretty-printer for holes and the pretty-printer for annotations.

Although the implementations don't know about each other, they can still be composed; as a result, a Holey Ast knows how to print itself using a mixture of the pretty-printer for Asts and the pretty-printer for Holes.

Minimal complete definition

pretty

Methods

pretty :: a -> String

Instances

Pretty (f (Fix f)) => Pretty (Fix f)

Pretty-printer for fixpoints.

Methods

pretty :: Fix f -> String

Pretty t => Pretty (AstF t)

Pretty-printer for ASTs.

Methods

pretty :: AstF t -> String

Pretty (f (Fix (HoleF f))) => Pretty (HoleF f (Fix (HoleF f)))

Pretty-printer for holes.

Methods

pretty :: HoleF f (Fix (HoleF f)) -> String

(Pretty (f (Fix (AnnotatedF a f))), Show a) => Pretty (AnnotatedF a f (Fix (AnnotatedF a f)))

Pretty-printer for annotations.

Methods

pretty :: AnnotatedF a f (Fix (AnnotatedF a f)) -> String

expr1 :: Ast

A simple expression

expr2 :: Ast

Another simple expression

expr3 :: Holey Ast

An expression-with-holes. Holes can be plugged with plug.

λ> pretty expr3 "|(_ + 1.0)|"

λ> pretty (plug (Var "z") expr3) "|(z + 1.0)|"

λ> :t plug (Var "z") expr3 plug (Var "z") expr3 :: Fix AstF -- aka Ast

data Type

Real and Complex type tags

Constructors

R

C

Instances

Eq Type

Methods

(==) :: Type -> Type -> Bool

(/=) :: Type -> Type -> Bool

Show Type

Methods

showsPrec :: Int -> Type -> ShowS

show :: Type -> String

showList :: [Type] -> ShowS

inferTypes :: Ast -> Annotated Type Ast

Annotate each subexpression with its type (real or complex).

λ> pretty expr1 "|((2.0 * (0.0 + 1.0i)) + 1.0)|"

λ> pretty (inferTypes expr1) "|((2.0{R} * (0.0 + 1.0i){C}){C} + 1.0{R}){C}|{R}"

unreal :: Ast -> Holey Ast

Remove all real-valued subexpressions, leaving a Hole in their place.

λ> pretty expr2 "((z * z) + (3.0 * z))"

λ> pretty (unreal expr2) "((z * z) + (_ * z))"