Text.Syntactical.Data

The data structures (and associated functions) used in the parser. For a normal usage, it should be enough to import only Text.Syntactical, not directly this module.

Documentation

data SExpr a

The s-expression data type used as input and output of the parser. The type is parametrized by the type of the token.

Constructors

List [SExpr a]

Atom a

Instances

Eq a => Eq (SExpr a)

Show a => Show (SExpr a)

data Tree a

The s-expression data type augmented to represent parts (used in the operator stack).

Constructors

Branch [Tree a]

Leaf a

Part (Part a)

Instances

Eq a => Eq (Tree a)

Show a => Show (Tree a)

data Op a

The operator representation, parametrized by the token type. It allows infix, prefix, postfix, and closed operators, with possibly multiple internal holes. Different holes are possible, to drive the parse in specific ways.

Constructors

Op1 Bool a [(Hole, a)] Opening Precedence

Op2 Bool a [(Hole, a)] Hole a

Instances

Eq a => Eq (Op a)

Show a => Show (Op a)

data Opening

Constructors

Infix Associativity

Prefix

Postfix

Instances

Eq Opening

Show Opening

data Associativity

Specify the associativity of an infix operator.

Constructors

NonAssociative

LeftAssociative

RightAssociative

Instances

Eq Associativity

Show Associativity

data Hole

The Hole is used to give various behaviours when dealing with internal holes.

Constructors

SExpression

SExpression means the content of the hole should be parsed as an s-expression. The resulting value is a List. This means the hole can be empty or contain one or more sub-expression(s).

Distfix

Distfix means the content of the hole should be parsed as a distfix expression. In this case feeding an empty hole will generate a parse error.

Instances

Eq Hole

Show Hole

data Part a

A Part represent a single symbol of an operator.

Constructors

First (Maybe (Associativity, Precedence)) a [a] Hole

Last (Op a)

Lone Bool a Opening Precedence

Middle [a] a [a] Hole

Instances

Eq a => Eq (Part a)

Show a => Show (Part a)

data Table a

The type of the operator table.

data Priority

Constructors

Lower

Higher

NoPriority

infx :: Associativity -> a -> Op a

Build a infix operator. The precedence is set to 0.

prefx :: a -> Op a

Build a prefix operator. The precedence is set to 0.

postfx :: a -> Op a

Build a postfix operator. The precedence is set to 0.

closed :: a -> Hole -> a -> Op a

Build a closed operator. The precedence is set to 0.

infx_ :: Associativity -> a -> Op a

Build a infix operator with the keep property set to False. The precedence is set to 0.

prefx_ :: a -> Op a

Build a prefix operator with the keep property set to False. The precedence is set to 0.

postfx_ :: a -> Op a

Build a postfix operator with the keep property set to False. The precedence is set to 0.

closed_ :: a -> Hole -> a -> Op a

Build a closed operator with the keep property set to False. The precedence is set to 0.

sexpr :: Op a -> a -> Op a

Add a new part separated by an SExpression hole to the right of an operator.

distfix :: Op a -> a -> Op a

Add a new part separated by a Distfix hole to the right of an operator.

buildTable :: [[Op a]] -> Table a

buildTable constructs an operator table that can be used with the shunt function. Operators are given in decreasing precedence order.

cut :: Op a -> [Part a]

Separate an operator in its different parts.

setPrecedence :: Precedence -> Op a -> Op a

Set the precedence of a given operator.

begin :: Part a -> Bool

end :: Part a -> Bool

leftOpen :: Part a -> Bool

rightOpen :: Part a -> Bool

rightHole :: Part a -> Maybe Hole

discard :: Part a -> Bool

applicator :: Token a => Table a -> SExpr a -> Bool

applicator' :: Token a => Table a -> Tree a -> Bool

continue :: Token a => Part a -> Part a -> Bool

original :: Part a -> Op a

priority :: Part a -> Part a -> Priority

arity :: Part a -> Int

Return the arity of a complete Part. It is an error to call this function on a First or Middle part.

symbol :: Part a -> a

Return the token of a given Part.

symbols :: Op a -> [a]

Return all the tokens of a given operator.

next :: Part a -> [a]

Return the possible tokens continuing the given part.

previous :: Part a -> [a]

Return the tokens preceding the given part.

current :: Part a -> [a]

Return the tokens of the given part.

findBoth :: Token a => Table a -> a -> [Tree a] -> FindBoth a

findBegin :: Token a => Table a -> a -> FindBegin a

data FindBegin a

Constructors

NoBegin

Begin (Part a)

MissingBegin [[a]]

AmbiguousBegin Ambiguity

data FindBoth a

Constructors

BNothing

BContinue (Part a)

BBegin (Part a)

BMissingBegin [[a]]

BAmbiguous Ambiguity

data Ambiguity

Constructors

MiddleOrLast

NotSameHole

NotSameFirst

LoneOrFirst

MultipleLone

Instances

Eq Ambiguity

Show Ambiguity

class Token a where

The class of the types that can be parsed.

Methods

toString :: a -> String

convert to a string (for showing purpose)

operator :: Op a -> [SExpr a] -> SExpr a

create an output node from an operator and its arguments

consider :: a -> a -> Bool

test if two tokens are the same (used to find match from the operator table). A default definition that compares the result of toString is provided.

showPart :: Token a => Part a -> String

showSExpr :: Token a => SExpr a -> String

Show an s-expression using nested angle brackets.

showTree :: Token a => Tree a -> String