# 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`.