Pinchot.SyntaxTree.Instancer

Documentation

bifunctorInstances :: [Rule t] -> DecsQ

Creates an instance of Bifunctor for every Rule in the Seq as well as their ancestors.

This function must be spliced in the same module as the module in which the syntax tree types are created. This avoids problems with orphan instances. Since ancestors are included, you can get the entire tree of instances that you need by applying this function to a single start symbol.

Example: Pinchot.Examples.SyntaxTrees.

semigroupInstances :: [Rule t] -> DecsQ

Where possible, creates an instance of Semigroup for every Rule in the Seq as well as their ancestors. Only star and plus rules, as well as rules that through one or more layers of wrap ultimately wrap a star or plus rule, get a Semigroup instance.

This function must be spliced in the same module as the module in which the syntax tree types are created. This avoids problems with orphan instances. Since ancestors are included, you can get the entire tree of instances that you need by applying this function to a single start symbol.

Example: Pinchot.Examples.SyntaxTrees.

monoidInstances :: [Rule t] -> DecsQ

Where possible, creates an instance of Monoid for every Rule in the Seq as well as their ancestors. Only star rules, as well as rules that through one or more layers of wrap ultimately wrap a star rule, get a Monoid instance.

This function must be spliced in the same module as the module in which the syntax tree types are created. This avoids problems with orphan instances. Since ancestors are included, you can get the entire tree of instances that you need by applying this function to a single start symbol.

Example: Pinchot.Examples.SyntaxTrees.

bimapExpression :: Qualifier -> Rule t -> ExpQ

bimapLetBinds

Arguments

:: Qualifier

-> Name

(a -> b)

-> Name

(c -> d)

-> Map RuleName Name

Looks up names for other let binds

-> Rule t

-> Q [DecQ]

bimapLetBind

Arguments

:: Qualifier

-> Name

(a -> b)

-> Name

(c -> d)

-> Map RuleName Name

-> Rule t

-> Q DecQ

terminalBimapLetBind :: Qualifier -> Name -> Name -> Map RuleName Name -> RuleName -> Q DecQ

nonTerminalBimapLetBind :: Qualifier -> Map RuleName Name -> RuleName -> [Branch a] -> DecQ

wrapBimapLetBind :: Qualifier -> Map RuleName Name -> RuleName -> RuleName -> Q DecQ

recordBimapLetBind :: Qualifier -> Map RuleName Name -> RuleName -> [Rule t] -> Q DecQ

recordBimapClause :: Qualifier -> Map RuleName Name -> RuleName -> [Rule t] -> ClauseQ

recordBimapLetBindField :: Map RuleName Name -> Rule t -> Q (PatQ, ExpQ)

optBimapLetBind

Arguments

:: Qualifier

-> Map RuleName Name

-> RuleName

Name of this rule

-> RuleName

Name of inner rule

-> Q DecQ

starBimapLetBind

Arguments

:: Qualifier

-> Map RuleName Name

-> RuleName

Name of this rule

-> RuleName

Name of inner rule

-> Q DecQ

plusBimapLetBind

Arguments

:: Qualifier

-> Map RuleName Name

-> RuleName

Name of this rule

-> RuleName

Name of inner rule

-> Q DecQ

seriesBimapLetBind :: Qualifier -> Name -> Name -> Map RuleName Name -> RuleName -> Q DecQ

errLookup :: (Ord a, Show a) => a -> Map a b -> b

nameMap :: Rule t -> Q (Map RuleName Name)

Creates a map of all ancestor rule names and a corresponding TH name.

memptyExpression :: Qualifier -> Rule t -> Maybe ExpQ

If possible, creates an expression of type

RuleData

which is a Monoid mempty.

wrappedMemptyExpression :: Qualifier -> [RuleName] -> ExpQ

mappendExpression :: Qualifier -> Rule t -> Maybe ExpQ

If possible, creates an expression of type

RuleData -> RuleData -> RuleData

which is a Monoid mappend.

monoidCtors :: Rule t -> Maybe [RuleName]

semigroupExpression :: Qualifier -> Rule t -> Maybe ExpQ

If possible, creates an expression of type

RuleData -> RuleData -> RuleData

which is a Semigroup <>.

semigroupCtors :: Rule t -> Maybe [RuleName]

wrappedSemigroupExpression

Arguments

:: Name

mappend operator

-> Qualifier

-> [RuleName]

Rule names, with the outermost name on the left side of the Seq.

-> ExpQ

An expression of type

RuleData -> RuleData -> RuleData

It unwraps the two argument types, uses the Semigroup <> operator to combine them, and rewraps the result.

prettyExpression :: Qualifier -> Rule t -> ExpQ

Creates an expression of type

RuleData -> Value

prettyInstance :: Rule t -> DecQ

Creates a PrettyVal instance. This must be spliced into the same module in which the corresponding data type is spliced.

prettyInstanceFamily :: Rule t -> DecsQ

Creates a PrettyVal instance for a rule and all its ancestors.

prettyInstances :: [Rule t] -> DecsQ

Creates a PrettyVal instance for each Rule in the Seq, as well as for all the ancestors of each Rule in the Seq.

This function must be spliced in the same module as the module in which the syntax tree types are created. This avoids problems with orphan instances. Since ancestors are included, you can get the entire tree of instances that you need by applying this function to a single start symbol.

Example: Pinchot.Examples.SyntaxTrees.

prettyExpressionInEnv

Arguments

:: Qualifier

-> Map RuleName Name

All expressions

-> Rule t

-> ExpQ

Creates an expression of type

RuleData -> Value

prettyBranches :: Qualifier -> Map RuleName Name -> NonEmpty (Branch t) -> ExpQ

lookupRule :: Map RuleName Name -> RuleName -> Q Name

deconstruct

Arguments

:: Name

Name of the constructor

-> Int

Create this many fields

-> ([ExpQ] -> ExpQ)

Each expression that results from each field is passed to this function.

-> Q (PatQ, ExpQ)

Creates a MatchQ when given a value constructor name and functions that work on the field values.

prettyBranch :: Qualifier -> Map RuleName Name -> Branch t -> MatchQ

prettyConstructor

Arguments

:: Qualifier

-> Map RuleName Name

-> String

Name of branch, or name of data constructor

-> [Rule t]

-> Q (PatQ, ExpQ)