next node: ParserL,
prev node: ParserLBasic,
up to node: Subsystem Parser Light


ParserLCombinator

Signature of ParserLCombinator

List of Import References :
See BOOL
See Char
See DENOTATION
See Nat
See Option
See ParserL
See Seq
See String
See Void

SIGNATURE ParserLCombinator[data]

$Date: 2010-09-30 18:24:17 +0200 (Do, 30. Sep 2010) $ ($Revision: 616 $)

Parameter

SORT data

Imports

IMPORT 
       Nat ONLY nat
       Option[data] ONLY option
       ParserL[void] ONLY parser
       ParserL[data] ONLY parser
       ParserL[seq]  ONLY parser
       ParserL[option] ONLY parser
       Seq[data] ONLY seq
       String ONLY string
       Void ONLY void

Sequencing

lift functions from sequences

FUN <> : parser[seq[data]]
FUN :: : parser[data] ** parser[seq[data]] -> parser[seq[data]]
FUN ++ : parser[seq[data]] ** parser[seq[data]] -> parser[seq[data]]

Repeaters

repeat parser at most/at least this much

FUN max: nat ** parser[data] -> parser[seq[data]]
FUN min: nat ** parser[data] -> parser[seq[data]]

(from, to) x P between from and to times (inclusive)

FUN x : nat ** nat ** parser[data] -> parser[seq[data]]

exactly this much

FUN x : nat ** parser[data] -> parser[seq[data]]

repeat any time as long as possible

FUN * : parser[data] -> parser[seq[data]]

at least once

FUN + : parser[data] -> parser[seq[data]]

once or never

FUN ? : parser[data] -> parser[option[data]]

Repeat until context fulfills predicate or parser[void] succeeds

FUN until: parser[data] ** (string -> bool) -> parser[seq[data]]
FUN until: parser[data] ** parser[void] -> parser[seq[data]]

Pre- and Postfixes

add Prefix

FUN <| : parser[void] ** parser[data] -> parser[data]

add postfix

FUN |> : parser[data] ** parser[void] -> parser[data]

add as pre- and postfix

FUN <|> : parser[data] ** parser[void] -> parser[data]

like the functions above, but with parser[void] as separator

FUN * : parser[data] ** parser[void] -> parser[seq[data]]
FUN + : parser[data] ** parser[void] -> parser[seq[data]]

Ignoring

map returned data to void type

FUN ignore: parser[data] -> parser[void]

recognize the string, return the data, but do not change context

FUN phantom: parser[data] -> parser[data]


next node: ParserL,
prev node: ParserLBasic,
up to node: Subsystem Parser Light