Previous  Up  Next

Module Cf_parser

module Cf_parser: sig .. end

Functional LL(x) parsing with monadic combinators.

This module implements function left-shift/left-reduce parser combinators using a state-exception monad over the input stream. To evaluate a parser monad is to parse an input stream. The state monad is lifted into the exception monad to facilitate backtracking. Parsers should signal errors in the input stream with ordinary Objective Caml exceptions.

type ('i, 'o) t = 'i Cf_seq.t -> ('o * 'i Cf_seq.t) option

The parser monad. A function that parses a sequence of input tokens. Returns None if the parser does not recognize any symbols. Otherwise returns the reduced output and the remainder of the input tokens.

exception Error

Generic parser error with no parameters.

val nil : ('i, 'o) t

A parser that never recognizes any input, i.e. it always returns None.

val err : ?f:('i Cf_seq.t -> exn) -> unit -> ('i, 'x) t

Use err ?f () to compose parser that applies the input token stream to the optional function f to obtain an Objective Caml exception, then raises the exception. The default function simply raises Error.

val req : ?f:('i Cf_seq.t -> exn) -> ('i, 'o) t -> ('i, 'o) t

Use req f p to create a parser that requires the input stream to match the parser p or it will be passed to the parser err f instead.

val fin : ('i, unit) t

A parser that produces the unit value when it recognizes the end of the input token sequence.

val alt : ('i, 'o) t list -> ('i, 'o) t

Use alt plist to create a parser that produces the output from the first parser in the list plist that recognizes a pattern in the input. If no parser in the list recognizes a pattern, then the parser constructed by this function returns None.

val altz : ('i, 'o) t Cf_seq.t -> ('i, 'o) t

Use altz pseq to create a parser that produces the output from the first parser in the lazy sequence pseq that recognizes a pattern in the input. If no parser in the sequence recognizes a pattern, then the parser constructed by this function returns None.

val sat : ('i -> bool) -> ('i, 'i) t

Use sat f to create a parser that recognizes, shifts and reduces input tokens for which the satisfier function f returns true.

val tok : ('i -> 'o option) -> ('i, 'o) t

Use tok f to recognize and shift input tokens for which the tokenizer function f reduces an output value.

val lit : string -> 'o -> (char, 'o) t

Use lit s obj to obtain a parser on character input sequences that produces the output obj when it recognizes the literal s in the input.

val unfold : ('i, 'o) t -> 'i Cf_seq.t -> 'o Cf_seq.t

Use unfold p i to create a sequence of output values recognized by applying the input token sequence i to the parser p until no more input is recognized.

class ['i] cursor : int -> object .. end

A class useful for tracking the position in the input token stream that corresponds to the head of the sequence passed to a parser.

module X: sig .. end

A module of parser extensions for working with input sequences that require position information in the parse function.

module Op: sig .. end

Open this module to take the parser operators into the current scope.

val filter : ('o -> bool) -> ('i, 'o) t -> ('i, 'o) t

Use filter f p to produce a parser that applies f to each output symbol of p and ignores all those for which the result is false.

val map : ('x -> 'y) -> ('i, 'x) t -> ('i, 'y) t

Use map f p to produce a parser that transforms each output symbol of p by applying f to its value.

val optmap : ('x -> 'y option) -> ('i, 'x) t -> ('i, 'y) t

Use optmap f p to produce a parser that transforms each output symbol of p by applying f to its value and ignoring all those for which the result is None.

val to_extended : ('i, 'o) t -> ('a #cursor, 'i, 'o) X.t

Use to_extended p to convert the parser p into an extended parser that ignores the position information woven into the input stream.

val of_extended : ('i #cursor as 'c) ->
       ('c, 'i, 'o) X.t -> ('i, 'o) t

Use of_extended c p to convert the parser p that requires position information in the input stream into a parser that assumes the input begins at the position of the cursor c.