Text.Derp

Data Types

data Parser t a

Represents both a formal context-free language and the reduction of a member of that language to a value of type a.

Instances

Show (Parser t a)

data Token t

Constructors

Token

Fields

tokenClass :: t

tokenValue :: String

Instances

Eq t => Eq (Token t)

Ord t => Ord (Token t)

Show t => Show (Token t)

Parser construction

(<|>) :: (Ord t, Ord a) => Parser t a -> Parser t a -> Parser t a

Alternation.

(<~>) :: (Ord t, Ord a, Ord b) => Parser t a -> Parser t b -> Parser t (a, b)

Concatenation.

(==>) :: (Ord t, Ord a, Ord b) => Parser t a -> (a -> b) -> Parser t b

Reduction.

nul :: (Ord t, Ord a) => Parser t a -> Parser t a

Null-parse extraction.

ter :: Ord t => t -> Parser t String

Terminal.

eps :: (Ord t, Ord a) => a -> Parser t a

Epsilon/empty-string.

emp :: (Ord t, Ord a) => Parser t a

The empty language.

Parser computation steps

derive :: Parser t a -> Token t -> Parser t a

The main derivative function.

compact :: Parser t a -> Parser t a

The optimization step of the algorithm.

parseNull :: (Ord t, Ord a) => Parser t a -> Set a

Extract the parse-null set of a parser.

Full parsing and result extraction

defaultCompactSteps :: Int

The number of compact steps that usually keeps a parser constant in size while parsing.

compactNum :: Int -> Parser t a -> Parser t a

A specified number of compactions.

deriveStepNum :: Int -> Parser t a -> Token t -> Parser t a

Derivation followed by a specified number of compactions.

runParseNum :: (Ord t, Ord a) => Int -> Parser t a -> [Token t] -> Set a

Parse using a specified number of intermediate compactions.

runParseStagesNum :: (Ord t, Ord a) => Int -> Parser t a -> [Token t] -> [(Parser t a, Set a, [Token t])]

runParseStages :: (Ord t, Ord a) => Parser t a -> [Token t] -> [(Parser t a, Set a, [Token t])]

runParseLongestMatchNum :: (Ord t, Ord a) => Int -> Parser t a -> [Token t] -> Maybe (Int, Set a, [Token t])

runParseLongestMatch :: (Ord t, Ord a) => Parser t a -> [Token t] -> Maybe (Int, Set a, [Token t])

deriveStep :: Parser t a -> Token t -> Parser t a

Derivation followed by the default number of compactions.

runParse :: (Ord t, Ord a) => Parser t a -> [Token t] -> Set a

Parse using the default number of intermediate compactions. This is the main parsing function. Examples:

 let e =     ter "num"
         <|> e <~> ter "+" <~> e ==> (\(x1,(o,x2)) -> "(" ++ x1 ++ o ++ x2 ++ ")")
 in runParse e [Token "num" "1", Token "+" "+", Token "num" 3", Token "+" "+", Token "num" "5"]

evaluates to:

 Set.fromList ["((1+3)+5)", "(1+(3+5))"]

 let e =     ter "num" ==> read 
         <|> e <~> ter "+" <~> e ==> (\(x1,(_,x2)) -> x1 + x2)
 in runParse e [Token "num" "1", Token "+" "+", Token "num" 3", Token "+" "+", Token "num" "5"]

evaluates to:

 Set.fromList [9]

Demos

xsR :: () -> Parser String String

xsL :: () -> Parser String String

xsIn :: [Token String]

parens :: () -> Parser String String

parensIn :: [Token String]

amb :: () -> Parser String String

ambIn :: [Token String]

sexp :: () -> Parser String String

sexpIn :: [Token String]

someStuff :: [Token String]

someStuffG :: () -> Parser String String