Codec.Phaser.Common

Common functions which do not need to be in Core, mostly for using Phases and Automatons as parsers.

Documentation

data Position

A data type for describing a position in a text file. Constructor arguments are row number and column number.

Constructors

Position !Int !Int

Instances

Eq Position

Methods

(==) :: Position -> Position -> Bool

(/=) :: Position -> Position -> Bool

Ord Position

Methods

compare :: Position -> Position -> Ordering

(<) :: Position -> Position -> Bool

(<=) :: Position -> Position -> Bool

(>) :: Position -> Position -> Bool

(>=) :: Position -> Position -> Bool

max :: Position -> Position -> Position

min :: Position -> Position -> Position

Read Position

Methods

readsPrec :: Int -> ReadS Position

readList :: ReadS [Position]

readPrec :: ReadPrec Position

readListPrec :: ReadPrec [Position]

Show Position

Methods

showsPrec :: Int -> Position -> ShowS

show :: Position -> String

showList :: [Position] -> ShowS

Monoid Position

Methods

mempty :: Position

mappend :: Position -> Position -> Position

mconcat :: [Position] -> Position

class PhaserType s where

Class for types which consume and produce incremental input and output.

Minimal complete definition

toAutomaton, fromAutomaton, toPhase, fromPhase, ($#$)

Methods

toAutomaton :: Monoid p => s p i o a -> Automaton p i o a

fromAutomaton :: Monoid p => Automaton p i o a -> s p i o a

toPhase :: Monoid p => s p i o a -> Phase p i o a

fromPhase :: Monoid p => Phase p i o a -> s p i o a

($#$) :: Monoid p => s p b c x -> (c -> t) -> s p b t x infixl 5

Instances

PhaserType Phase

Methods

toAutomaton :: Monoid p => Phase p i o a -> Automaton p i o a

fromAutomaton :: Monoid p => Automaton p i o a -> Phase p i o a

toPhase :: Monoid p => Phase p i o a -> Phase p i o a

fromPhase :: Monoid p => Phase p i o a -> Phase p i o a

($#$) :: Monoid p => Phase p b c x -> (c -> t) -> Phase p b t x

PhaserType Automaton

Methods

toAutomaton :: Monoid p => Automaton p i o a -> Automaton p i o a

fromAutomaton :: Monoid p => Automaton p i o a -> Automaton p i o a

toPhase :: Monoid p => Automaton p i o a -> Phase p i o a

fromPhase :: Monoid p => Phase p i o a -> Automaton p i o a

($#$) :: Monoid p => Automaton p b c x -> (c -> t) -> Automaton p b t x

class Standardized r a where

Class for types which have standardized or otherwise unambiguous representations. Implementations of regular may be more permissive than the corresponding Read instance (if any).

Minimal complete definition

regular

Methods

regular :: Monoid p => Phase p r o a

Instances

Standardized Char Bool

Methods

regular :: Monoid p => Phase p Char o Bool

Standardized Char Double

Methods

regular :: Monoid p => Phase p Char o Double

Standardized Char Float

Methods

regular :: Monoid p => Phase p Char o Float

Standardized Char Int

Methods

regular :: Monoid p => Phase p Char o Int

Standardized Char Int8

Methods

regular :: Monoid p => Phase p Char o Int8

Standardized Char Int16

Methods

regular :: Monoid p => Phase p Char o Int16

Standardized Char Int32

Methods

regular :: Monoid p => Phase p Char o Int32

Standardized Char Int64

Methods

regular :: Monoid p => Phase p Char o Int64

Standardized Char Integer

Methods

regular :: Monoid p => Phase p Char o Integer

Standardized Char Word

Methods

regular :: Monoid p => Phase p Char o Word

Standardized Char Word8

Methods

regular :: Monoid p => Phase p Char o Word8

Standardized Char Word16

Methods

regular :: Monoid p => Phase p Char o Word16

Standardized Char Word32

Methods

regular :: Monoid p => Phase p Char o Word32

Standardized Char Word64

Methods

regular :: Monoid p => Phase p Char o Word64

(Integral a, Standardized Char a) => Standardized Char (Ratio a)

Methods

regular :: Monoid p => Phase p Char o (Ratio a)

data Trie c a

Tries in this module can be used for creating more efficient parsers when several of the recognized strings begin with the same few characters

Instances

Ord c => Monoid (Trie c a)

Methods

mempty :: Trie c a

mappend :: Trie c a -> Trie c a -> Trie c a

mconcat :: [Trie c a] -> Trie c a

newTrie :: Ord c => [c] -> a -> Trie c a

Create a trie which maps a single string to an object. Analogous to singleton.

fromTrie :: (Monoid p, PhaserType s, Ord c) => Trie c a -> s p c o a

Create a Phase or Automaton from a Trie

satisfy :: Monoid p => (i -> Bool) -> Phase p i o i

Consume one input, return it if it matches the predicate, otherwise fail.

match :: (Eq i, Monoid p) => i -> Phase p i o i

Consume one input, if it's equal to the parameter then return it, otherwise fail.

char :: Monoid p => Char -> Phase p Char o Char

match specialized to Char

iChar :: Monoid p => Char -> Phase p Char o Char

Case insensitive version of char

string :: (Eq i, Monoid p) => [i] -> Phase p i o [i]

Match a list of input values

iString :: Monoid p => String -> Phase p Char o String

Match a string (case insensitive)

integerDecimal :: (Num a, Monoid p) => Phase p Char o a

Parse a standard base 10 integer

positiveIntegerDecimal :: (Num a, Monoid p) => Phase p Char o a

Parse a standard positive base 10 integer

decimal :: (Fractional a, Monoid p) => Phase p Char o a

Parse a number from decimal digits, "-", and "."

scientificNotation :: (Fractional a, Monoid p) => Phase p Char o a

Parse a number from standard decimal format or from scientific notation.

directHex :: (Num a, Monoid p) => Phase p Char o a

Take some hexadecimal digits and parse a number from hexadecimal

hex :: (Num a, Monoid p) => Phase p Char o a

Parse a hexadecimal number prefixed with Ox

positiveInteger :: (Num a, Monoid p) => Phase p Char o a

Parse a positive integer from either decimal or hexadecimal format

integer :: (Num a, Monoid p) => Phase p Char o a

Parse a number either from decimal digits or from hexadecimal prefixed with "0x"

countChar :: Phase Position i o ()

Move the position counter one character to the right

countLine :: Phase Position i o ()

Move the position counter to the next line

trackPosition :: Phase Position Char Char ()

Count the lines and characters from the input before yielding them again. If the phase pipeline does not include this or similar: parsing errors will not report the correct position. Unix, Windows, Mac-OS Classic, and Acorn newline formats are all recognized.

normalizeNewlines :: Monoid p => Phase p Char Char ()

Converts all line separators into Unix format.

parse :: PhaserType s => s Position i o a -> [i] -> Either [(Position, [String])] [a]

Use a Phase as a parser. Note that unlike other parsers the reported position in the input when the parser fails is the position reached when all parsing options are exhausted, not the beginning of the failing token. Since the characters may be counted nondeterministically: if multiple errors are returned the reported error position may be different for each error report.

sepBy :: Monoid p => Phase p i o a -> Phase p i o s -> Phase p i o [a]

sepBy p sep parses zero or more occurrences of p, separated by sep. Returns a list of values returned by p.

sepBy1 :: Monoid p => Phase p i o a -> Phase p i o s -> Phase p i o [a]

sepBy1 p sep parses one or more occurrences of p, separated by sep. Returns a list of values returned by p.

munch :: Monoid p => (i -> Bool) -> Phase p i o [i]

Parses the first zero or more values satisfying the predicate. Always succeds, exactly once, having consumed all the characters Hence NOT the same as (many (satisfy p))

munch1 :: Monoid p => (i -> Bool) -> Phase p i o [i]

Parses the first one or more values satisfying the predicate. Succeeds if at least one value matches, having consumed all the characters Hence NOT the same as (some (satisfy p))

parseFile :: PhaserType s => s Position Word8 o a -> FilePath -> IO (Either [(Position, [String])] [a])

Run a parser on input from a file. Input is provided as bytes, if characters are needed: a decoding phase such as utf8_stream or latin1 may be used

latin1 :: Monoid p => Phase p Word8 Char ()

Decode bytes to characters using the Latin1 (ISO8859-1) encoding