uulib-0.9.20: Haskell Utrecht Tools Library

Safe Haskell | None
Language | Haskell98

UU.Parsing.MachineInterface

Synopsis

- class InputState state s pos | state -> s, state -> pos where
- class OutputState r where
- class Symbol s where
- data Either' state s
  - = Left' !s state
  - | Right' state
- data Steps val s p
  - = OkVal (a -> val) (Steps a s p)
  - | Ok {
    - rest :: Steps val s p
    }
  - | Cost {
    - costing :: Int#
    - rest :: Steps val s p
    }
  - | StRepair {
    - costing :: Int#
    - m :: !(Message s p)
    - rest :: Steps val s p
    }
  - | Best (Steps val s p) (Steps val s p) (Steps val s p)
  - | NoMoreSteps val
- data Action s
  - = Insert s
  - | Delete s
  - | Other String
- val :: (a -> b) -> Steps a s p -> Steps b s p
- evalSteps :: Steps a s p -> a
- getMsgs :: Steps a s p -> [Message s p]
- data Message sym pos = Msg (Expecting sym) !pos (Action sym)
- data Expecting s
  - = ESym (SymbolR s)
  - | EStr String
  - | EOr [Expecting s]
  - | ESeq [Expecting s]
- data SymbolR s
  - = Range !s !s
  - | EmptyR
- mk_range :: Ord s => s -> s -> SymbolR s
- symInRange :: Ord a => SymbolR a -> a -> Bool
- symRS :: Ord a => SymbolR a -> a -> Ordering
- except :: (Symbol s, Ord s, Foldable t) => SymbolR s -> t s -> [SymbolR s]
- usererror :: [Char] -> a
- systemerror :: [Char] -> [Char] -> a

# Documentation

class InputState state s pos | state -> s, state -> pos where Source #

The `InputState` class contains the interface that the AnaParser parsers expect for the input. A minimal complete instance definition consists of `splitStateE`, `splitState` and `getPosition`.

Minimal complete definition

splitStateE, splitState, getPosition

Methods

splitStateE :: state -> Either' state s Source #

Splits the state in a strict variant of `Either`, with `Left'` if a symbol can be split off and `Right'` if none can

splitState :: state -> (#s, state#) Source #

Splits the state in the first symbol and the remaining state

getPosition :: state -> pos Source #

Gets the current position in the input

reportError :: Message s pos -> state -> state Source #

Reports an error

insertSymbol :: s -> state -> state Source #

Modify the state as the result of inserting a symbol `s` in the input. The symbol that has already been considered as having been inserted is passed. It should normally not be added to the state.

deleteSymbol :: s -> state -> state Source #

Modify the state as the result of deleting a symbol `s` from the input. The symbol that has already been deleted from the input state is passed. It should normally not be deleted from the state.

Instances

InputState Input Char Pos Source # |
Methods splitStateE :: Input -> Either' Input Char Source # splitState :: Input -> (#PtrRepLifted, PtrRepLifted, Char, Input#) Source # getPosition :: Input -> Pos Source # reportError :: Message Char Pos -> Input -> Input Source # insertSymbol :: Char -> Input -> Input Source # deleteSymbol :: Char -> Input -> Input Source #
InputState inp s p => InputState (OffsideInput inp s p) (OffsideSymbol s) p Source # |

Methods

splitStateE :: OffsideInput inp s p -> Either' (OffsideInput inp s p) (OffsideSymbol s) Source #

splitState :: OffsideInput inp s p -> (#PtrRepLifted, PtrRepLifted, OffsideSymbol s, OffsideInput inp s p#) Source #

getPosition :: OffsideInput inp s p -> p Source #

reportError :: Message (OffsideSymbol s) p -> OffsideInput inp s p -> OffsideInput inp s p Source #

insertSymbol :: OffsideSymbol s -> OffsideInput inp s p -> OffsideInput inp s p Source #

deleteSymbol :: OffsideSymbol s -> OffsideInput inp s p -> OffsideInput inp s p Source #

class OutputState r where Source #

Minimal complete definition

acceptR, nextR

Methods

acceptR :: v -> rest -> r v rest Source #

nextR :: (a -> rest -> rest') -> (b -> a) -> r b rest -> rest' Source #

Instances

OutputState Pair Source # |
Methods acceptR :: v -> rest -> Pair v rest Source # nextR :: (a -> rest -> rest') -> (b -> a) -> Pair b rest -> rest' Source #

class Symbol s where Source #

Methods

deleteCost :: s -> Int# Source #

symBefore :: s -> s Source #

symAfter :: s -> s Source #

Instances

Symbol s => Symbol (OffsideSymbol s) Source # |
Methods deleteCost :: OffsideSymbol s -> Int# Source # symBefore :: OffsideSymbol s -> OffsideSymbol s Source # symAfter :: OffsideSymbol s -> OffsideSymbol s Source #

data Either' state s Source #

Constructors

Left' !s state |
Right' state |

data Steps val s p Source #

Constructors

OkVal (a -> val) (Steps a s p) |
Ok |

Fields

- rest :: Steps val s p

Cost |

Fields

- costing :: Int#
- rest :: Steps val s p

StRepair |

Fields

- costing :: Int#
- m :: !(Message s p)
- rest :: Steps val s p

Best (Steps val s p) (Steps val s p) (Steps val s p) |
NoMoreSteps val |

data Action s Source #

Constructors

Insert s |
Delete s |
Other String |

Instances

Show s => Show (Action s) Source # |
Methods showsPrec :: Int -> Action s -> ShowS # show :: Action s -> String # showList :: [Action s] -> ShowS #

val :: (a -> b) -> Steps a s p -> Steps b s p Source #

evalSteps :: Steps a s p -> a Source #

getMsgs :: Steps a s p -> [Message s p] Source #

data Message sym pos Source #

Constructors

Msg (Expecting sym) !pos (Action sym) |

Instances

(Eq s, Show s, Show p) => Show (Message s p) Source # |
Methods showsPrec :: Int -> Message s p -> ShowS # show :: Message s p -> String # showList :: [Message s p] -> ShowS #

data Expecting s Source #

Constructors

ESym (SymbolR s) |
EStr String |
EOr [Expecting s] |
ESeq [Expecting s] |

Instances

Eq s => Eq (Expecting s) Source # |
Methods (==) :: Expecting s -> Expecting s -> Bool # (/=) :: Expecting s -> Expecting s -> Bool #
Ord s => Ord (Expecting s) Source # |
Methods compare :: Expecting s -> Expecting s -> Ordering # (<) :: Expecting s -> Expecting s -> Bool # (<=) :: Expecting s -> Expecting s -> Bool # (>) :: Expecting s -> Expecting s -> Bool # (>=) :: Expecting s -> Expecting s -> Bool # max :: Expecting s -> Expecting s -> Expecting s # min :: Expecting s -> Expecting s -> Expecting s #
(Eq s, Show s) => Show (Expecting s) Source # |
Methods showsPrec :: Int -> Expecting s -> ShowS # show :: Expecting s -> String # showList :: [Expecting s] -> ShowS #

data SymbolR s Source #

Constructors

Range !s !s |
EmptyR |

Instances

Eq s => Eq (SymbolR s) Source # |
Methods (==) :: SymbolR s -> SymbolR s -> Bool # (/=) :: SymbolR s -> SymbolR s -> Bool #
Ord s => Ord (SymbolR s) Source # |
Methods compare :: SymbolR s -> SymbolR s -> Ordering # (<) :: SymbolR s -> SymbolR s -> Bool # (<=) :: SymbolR s -> SymbolR s -> Bool # (>) :: SymbolR s -> SymbolR s -> Bool # (>=) :: SymbolR s -> SymbolR s -> Bool # max :: SymbolR s -> SymbolR s -> SymbolR s # min :: SymbolR s -> SymbolR s -> SymbolR s #
(Eq s, Show s) => Show (SymbolR s) Source # |
Methods showsPrec :: Int -> SymbolR s -> ShowS # show :: SymbolR s -> String # showList :: [SymbolR s] -> ShowS #

mk_range :: Ord s => s -> s -> SymbolR s Source #

symInRange :: Ord a => SymbolR a -> a -> Bool Source #

symRS :: Ord a => SymbolR a -> a -> Ordering Source #

except :: (Symbol s, Ord s, Foldable t) => SymbolR s -> t s -> [SymbolR s] Source #

usererror :: [Char] -> a Source #

systemerror :: [Char] -> [Char] -> a Source #