Language.Syntactic.Interpretation

Equality and rendering of ASTs

Equality

class Equality e where

Higher-kinded equality

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.

equal :: Render e => 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

hash :: Render e => 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

Defined in Language.Syntactic.Interpretation

Methods

equal :: Empty a -> Empty b -> Bool

hash :: Empty a -> Hash

Equality Let

Defined in Language.Syntactic.Functional

Methods

equal :: Let a -> Let b -> Bool

hash :: Let a -> Hash

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

Defined in Language.Syntactic.Functional

Methods

equal :: BindingT a -> BindingT b -> Bool

hash :: BindingT a -> Hash

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

Defined in Language.Syntactic.Functional

Methods

equal :: Binding a -> Binding b -> Bool

hash :: Binding a -> Hash

Equality Construct

Defined in Language.Syntactic.Functional

Methods

equal :: Construct a -> Construct b -> Bool

hash :: Construct a -> Hash

Equality Literal

Defined in Language.Syntactic.Functional

Methods

equal :: Literal a -> Literal b -> Bool

hash :: Literal a -> Hash

Equality Tuple

Defined in Language.Syntactic.Functional.Tuple

Methods

equal :: Tuple a -> Tuple b -> Bool

hash :: Tuple a -> Hash

Equality sym => Equality (Typed sym)

Defined in Language.Syntactic.Interpretation

Methods

equal :: Typed sym a -> Typed sym b -> Bool

hash :: Typed sym a -> Hash

Equality sym => Equality (AST sym)

Defined in Language.Syntactic.Interpretation

Methods

equal :: AST sym a -> AST sym b -> Bool

hash :: AST sym a -> Hash

Equality (MONAD m)

Defined in Language.Syntactic.Functional

Methods

equal :: MONAD m a -> MONAD m b -> Bool

hash :: MONAD m a -> Hash

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

Defined in Language.Syntactic.Interpretation

Methods

equal :: (sym1 :+: sym2) a -> (sym1 :+: sym2) b -> Bool

hash :: (sym1 :+: sym2) a -> Hash

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

Defined in Language.Syntactic.Decoration

Methods

equal :: (expr :&: info) a -> (expr :&: info) b -> Bool

hash :: (expr :&: info) a -> Hash

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

Defined in Language.Syntactic.Interpretation

Methods

renderSym :: Empty sig -> String

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

Render Let

Defined in Language.Syntactic.Functional

Methods

renderSym :: Let sig -> String

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

Render BindingT

Defined in Language.Syntactic.Functional

Methods

renderSym :: BindingT sig -> String

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

Render Binding

Defined in Language.Syntactic.Functional

Methods

renderSym :: Binding sig -> String

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

Render Construct

Defined in Language.Syntactic.Functional

Methods

renderSym :: Construct sig -> String

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

Render Literal

Defined in Language.Syntactic.Functional

Methods

renderSym :: Literal sig -> String

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

Render Tuple

Defined in Language.Syntactic.Functional.Tuple

Methods

renderSym :: Tuple sig -> String

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

Render sym => Render (Typed sym)

Defined in Language.Syntactic.Interpretation

Methods

renderSym :: Typed sym sig -> String

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

Render (MONAD m)

Defined in Language.Syntactic.Functional

Methods

renderSym :: MONAD m sig -> String

renderArgs :: [String] -> MONAD m sig -> String

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

Defined in Language.Syntactic.Interpretation

Methods

renderSym :: (sym1 :+: sym2) sig -> String

renderArgs :: [String] -> (sym1 :+: sym2) sig -> String

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

Defined in Language.Syntactic.Decoration

Methods

renderSym :: (expr :&: info) sig -> String

renderArgs :: [String] -> (expr :&: info) sig -> String

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

Methods

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

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

Instances

StringTree Empty

Defined in Language.Syntactic.Interpretation

Methods

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

StringTree Let

Defined in Language.Syntactic.Functional

Methods

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

StringTree BindingT

Defined in Language.Syntactic.Functional

Methods

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

StringTree Binding

Defined in Language.Syntactic.Functional

Methods

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

StringTree Construct

Defined in Language.Syntactic.Functional

Methods

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

StringTree Literal

Defined in Language.Syntactic.Functional

Methods

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

StringTree Tuple

Defined in Language.Syntactic.Functional.Tuple

Methods

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

StringTree sym => StringTree (Typed sym)

Defined in Language.Syntactic.Interpretation

Methods

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

StringTree (MONAD m)

Defined in Language.Syntactic.Functional

Methods

stringTreeSym :: [Tree String] -> MONAD m a -> Tree String

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

Defined in Language.Syntactic.Interpretation

Methods

stringTreeSym :: [Tree String] -> (sym1 :+: sym2) a -> Tree String

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

Defined in Language.Syntactic.Decoration

Methods

stringTreeSym :: [Tree String] -> (expr :&: info) a -> Tree String

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

Orphan instances

Equality sym => Eq (AST sym a)

Methods

(==) :: AST sym a -> AST sym a -> Bool

(/=) :: AST sym a -> AST sym a -> Bool

Render sym => Show (ASTF sym a)

Methods

showsPrec :: Int -> ASTF sym a -> ShowS

show :: ASTF sym a -> String

showList :: [ASTF sym a] -> ShowS

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

Methods

(==) :: (sym1 :+: sym2) a -> (sym1 :+: sym2) a -> Bool

(/=) :: (sym1 :+: sym2) a -> (sym1 :+: sym2) a -> Bool