Language.Syntactic.Interpretation

Equality and rendering of ASTs

Equality

class Equality e where

Higher-kinded equality

Minimal complete definition

Nothing

Methods

equal :: e a -> e b -> Bool

Higher-kinded equality

Comparing elements of different types is often needed when dealing with expressions with existentially quantified sub-terms.

hash :: e a -> Hash

Higher-kinded hashing. Elements that are equal according to equal must result in the same hash:

equal a b  ==>  hash a == hash b

Instances

Equality Empty

Equality Let

Equality BindingT

equal does strict identifier comparison; i.e. no alpha equivalence.

hash assigns the same hash to all variables and binders. This is a valid over-approximation that enables the following property:

alphaEq a b ==> hash a == hash b

Equality Binding

equal does strict identifier comparison; i.e. no alpha equivalence.

hash assigns the same hash to all variables and binders. This is a valid over-approximation that enables the following property:

alphaEq a b ==> hash a == hash b

Equality Construct

Equality Literal

Equality Tuple

Equality sym => Equality (Typed sym)

Equality sym => Equality (AST sym)

Equality (MONAD m)

(Equality sym1, Equality sym2) => Equality ((:+:) sym1 sym2)

Equality expr => Equality ((:&:) expr info)

Rendering

class Render sym where

Render a symbol as concrete syntax. A complete instance must define at least the renderSym method.

Minimal complete definition

renderSym

Methods

renderSym :: sym sig -> String

Show a symbol as a String

renderArgs :: [String] -> sym sig -> String

Render a symbol given a list of rendered arguments

Instances

Render Empty

Render Let

Render BindingT

Render Binding

Render Construct

Render Literal

Render Tuple

Render sym => Render (Typed sym)

Render (MONAD m)

(Render sym1, Render sym2) => Render ((:+:) sym1 sym2)

Render expr => Render ((:&:) expr info)

renderArgsSmart :: Render sym => [String] -> sym a -> String

Implementation of renderArgs that handles infix operators

render :: forall sym a. Render sym => ASTF sym a -> String

Render an AST as concrete syntax

class Render sym => StringTree sym where

Convert a symbol to a Tree of strings

Minimal complete definition

Nothing

Methods

stringTreeSym :: [Tree String] -> sym a -> Tree String

Convert a symbol to a Tree given a list of argument trees

Instances

StringTree Empty

StringTree Let

StringTree BindingT

StringTree Binding

StringTree Construct

StringTree Literal

StringTree Tuple

StringTree sym => StringTree (Typed sym)

StringTree (MONAD m)

(StringTree sym1, StringTree sym2) => StringTree ((:+:) sym1 sym2)

StringTree expr => StringTree ((:&:) expr info)

stringTree :: forall sym a. StringTree sym => ASTF sym a -> Tree String

Convert an AST to a Tree of strings

showAST :: StringTree sym => ASTF sym a -> String

Show a syntax tree using ASCII art

drawAST :: StringTree sym => ASTF sym a -> IO ()

Print a syntax tree using ASCII art

writeHtmlAST :: StringTree sym => FilePath -> ASTF sym a -> IO ()

Write a syntax tree to an HTML file with foldable nodes

Default interpretation

equalDefault :: Render sym => sym a -> sym b -> Bool

Default implementation of equal

hashDefault :: Render sym => sym a -> Hash

Default implementation of hash