uulib-0.9.20: Haskell Utrecht Tools Library

Safe Haskell | None
Language | Haskell98

UU.Parsing.Interface

Synopsis

- data AnaParser state result s p a
- pWrap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state -> Steps r s p) -> (state, Steps r'' s p, state -> Steps r s p)) -> (forall r. state -> Steps r s p -> (state -> Steps r s p) -> (state, Steps r s p, state -> Steps r s p)) -> AnaParser state result s p a -> AnaParser state result s p b
- pMap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state, Steps r'' s p)) -> (forall r. state -> Steps r s p -> (state, Steps r s p)) -> AnaParser state result s p a -> AnaParser state result s p b
- module UU.Parsing.MachineInterface
- type Parser s = AnaParser [s] Pair s (Maybe s)
- class (Applicative p, Alternative p, Functor p) => IsParser p s | p -> s where
  - pSucceed :: a -> p a
  - pLow :: a -> p a
  - pFail :: p a
  - pCostRange :: Int# -> s -> SymbolR s -> p s
  - pCostSym :: Int# -> s -> s -> p s
  - pSym :: s -> p s
  - pRange :: s -> SymbolR s -> p s
  - getfirsts :: p v -> Expecting s
  - setfirsts :: Expecting s -> p v -> p v
  - getzerop :: p v -> Maybe (p v)
  - getonep :: p v -> Maybe (p v)
- pCost :: (OutputState out, InputState inp sym pos, Symbol sym, Ord sym) => Int# -> AnaParser inp out sym pos ()
- getInputState :: (InputState a c d, Symbol c, Ord c, OutputState b) => AnaParser a b c d a
- handleEof :: (Symbol s, InputState a s p) => a -> Steps (Pair a ()) s p
- parse :: (Symbol s, InputState inp s pos) => AnaParser inp Pair s pos a -> inp -> Steps (Pair a (Pair inp ())) s pos
- parseIOMessage :: (Symbol s, InputState inp s p) => (Message s p -> String) -> AnaParser inp Pair s p a -> inp -> IO a
- parseIOMessageN :: (Symbol s, InputState inp s p) => (Message s p -> String) -> Int -> AnaParser inp Pair s p a -> inp -> IO a
- data Pair a r = Pair a r
- evalStepsIO :: (Message s p -> String) -> Steps b s p -> IO b
- evalStepsIO' :: (Message s p -> String) -> Int -> Steps b s p -> IO b
- (<*>) :: Applicative f => forall a b. f (a -> b) -> f a -> f b
- (<*) :: Applicative f => forall a b. f a -> f b -> f a
- (*>) :: Applicative f => forall a b. f a -> f b -> f b
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- (<$) :: Functor f => forall a b. a -> f b -> f a
- (<|>) :: Alternative f => forall a. f a -> f a -> f a

# Documentation

data AnaParser state result s p a Source

Instances

(InputState inp s p, OutputState out) => StateParser (AnaParser (inp, st) out s p) st Source |

(Ord s, Symbol s, InputState state s p, OutputState result) => IsParser (AnaParser state result s p) s Source

The fast `AnaParser` instance of the `IsParser` class. Note that this requires a functioning `Ord` for the symbol type s, as tokens are often compared using the `compare` function in `Ord` rather than always using `==` rom `Eq`. The two do need to be consistent though, that is for any two `x1`, `x2` such that `x1 == x2` you must have `compare x1 x2 == EQ`.

pWrap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state -> Steps r s p) -> (state, Steps r'' s p, state -> Steps r s p)) -> (forall r. state -> Steps r s p -> (state -> Steps r s p) -> (state, Steps r s p, state -> Steps r s p)) -> AnaParser state result s p a -> AnaParser state result s p b Source

pMap :: OutputState result => (forall r r''. (b -> r -> r'') -> state -> Steps (a, r) s p -> (state, Steps r'' s p)) -> (forall r. state -> Steps r s p -> (state, Steps r s p)) -> AnaParser state result s p a -> AnaParser state result s p b Source

module UU.Parsing.MachineInterface

type Parser s = AnaParser [s] Pair s (Maybe s) Source

class (Applicative p, Alternative p, Functor p) => IsParser p s | p -> s where Source

The `IsParser` class contains the base combinators with which to write parsers. A minimal complete instance definition consists of definitions for '(*)', '(|)', `pSucceed`, `pLow`, `pFail`, `pCostRange`, `pCostSym`, `getfirsts`, `setfirsts`, and `getzerop`. All operators available through `Applicative`, 'Functor", and `Alternative` have the same names suffixed with `:`.

Minimal complete definition

pLow, pCostRange, pCostSym, getfirsts, setfirsts, getzerop, getonep

Methods

pSucceed :: a -> p a Source

Two variants of the parser for empty strings. `pSucceed` parses the empty string, and fully counts as an alternative parse. It returns the value passed to it.

pLow :: a -> p a Source

`pLow` parses the empty string, but alternatives to pLow are always preferred over `pLow` parsing the empty string.

pFail :: p a Source

This parser always fails, and never returns any value at all.

pCostRange :: Int# -> s -> SymbolR s -> p s Source

Parses a range of symbols with an associated cost and the symbol to insert if no symbol in the range is present. Returns the actual symbol parsed.

pCostSym :: Int# -> s -> s -> p s Source

Parses a symbol with an associated cost and the symbol to insert if the symbol to parse isn't present. Returns either the symbol parsed or the symbol inserted.

pSym :: s -> p s Source

Parses a symbol. Returns the symbol parsed.

pRange :: s -> SymbolR s -> p s Source

getfirsts :: p v -> Expecting s Source

Get the firsts set from the parser, i.e. the symbols it expects.

setfirsts :: Expecting s -> p v -> p v Source

Set the firsts set in the parser.

getzerop :: p v -> Maybe (p v) Source

`getzerop` returns `Nothing` if the parser can not parse the empty string, and returns `Just p` with `p` a parser that parses the empty string and returns the appropriate value.

getonep :: p v -> Maybe (p v) Source

`getonep` returns `Nothing` if the parser can only parse the empty string, and returns `Just p` with `p` a parser that does not parse any empty string.

Instances

(Ord s, Symbol s, InputState state s p, OutputState result) => IsParser (AnaParser state result s p) s Source

The fast `AnaParser` instance of the `IsParser` class. Note that this requires a functioning `Ord` for the symbol type s, as tokens are often compared using the `compare` function in `Ord` rather than always using `==` rom `Eq`. The two do need to be consistent though, that is for any two `x1`, `x2` such that `x1 == x2` you must have `compare x1 x2 == EQ`.

(Symbol s, Ord s, InputState i s p, OutputState o) => IsParser (OffsideParser i o s p) s Source |

pCost :: (OutputState out, InputState inp sym pos, Symbol sym, Ord sym) => Int# -> AnaParser inp out sym pos () Source

getInputState :: (InputState a c d, Symbol c, Ord c, OutputState b) => AnaParser a b c d a Source

handleEof :: (Symbol s, InputState a s p) => a -> Steps (Pair a ()) s p Source

parse :: (Symbol s, InputState inp s pos) => AnaParser inp Pair s pos a -> inp -> Steps (Pair a (Pair inp ())) s pos Source

parseIOMessage :: (Symbol s, InputState inp s p) => (Message s p -> String) -> AnaParser inp Pair s p a -> inp -> IO a Source

parseIOMessageN :: (Symbol s, InputState inp s p) => (Message s p -> String) -> Int -> AnaParser inp Pair s p a -> inp -> IO a Source

data Pair a r Source

Constructors

Pair a r |

Instances

OutputState Pair Source |

evalStepsIO :: (Message s p -> String) -> Steps b s p -> IO b Source

evalStepsIO' :: (Message s p -> String) -> Int -> Steps b s p -> IO b Source

(<*>) :: Applicative f => forall a b. f (a -> b) -> f a -> f b

Sequential application.

(<*) :: Applicative f => forall a b. f a -> f b -> f a

Sequence actions, discarding the value of the second argument.

(*>) :: Applicative f => forall a b. f a -> f b -> f b

Sequence actions, discarding the value of the first argument.

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4

An infix synonym for `fmap`.

#### Examples

Convert from a ``Maybe` `Int`` to a ``Maybe` `String`` using `show`:

    >>> show <$> Nothing
    Nothing
    >>> show <$> Just 3
    Just "3"

Convert from an ``Either` `Int` `Int`` to an ``Either` `Int`` `String` using `show`:

    >>> show <$> Left 17
    Left 17
    >>> show <$> Right 17
    Right "17"

Double each element of a list:

    >>> (*2) <$> [1,2,3]
    [2,4,6]

Apply `even` to the second element of a pair:

    >>> even <$> (2,2)
    (2,True)

(<$) :: Functor f => forall a b. a -> f b -> f a

Replace all locations in the input with the same value. The default definition is ``fmap` . `const``, but this may be overridden with a more efficient version.

(<|>) :: Alternative f => forall a. f a -> f a -> f a

An associative binary operation