package fmlib

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Parameters
Signature
Final parser
Generic Combinators
Elementary Parsing Step
Make the Final Parser

package fmlib

Fmlib
- Library fmlib
  - Fmlib
- Library fmlib.fmlib_parse
  - Fmlib_parse
    
    Buffer
    
    Make
    
    Error
    
    Character
    
    Make
    
    Parser
    
    Character_state
    
    Make
    
    Error
    
    Make
    
    Generic
    
    Make
    
    Parser
    
    Indent
    
    Interfaces
    
    PARSER
    
    COMBINATOR
    
    Located
    
    Parse
    
    Character
    
    Generic
    
    Position
    
    Located
    
    Indent
    
    Interfaces
    
    Position
    
    Test_calculator
    
    CP
    
    Parser
    
    Test_character
    
    CP
    
    Parser
    
    SP
    
    Parser
    
    Indent_sensitive
    
    Basic
    
    Parser
    
    Parser
- Library fmlib.fmlib_pretty
  - Fmlib_pretty
    
    Pretty
    
    Print
    
    Print
    
    State
    
    Text
    
    Line
    
    Chunk
    
    Group
    
    Buffer
- Library fmlib.fmlib_std
  - Fmlib_std
    
    Array
    
    Deque
    
    Int
    
    Interfaces
    
    ANY
    
    MONAD
    
    SORTABLE
    
    SOURCE
    
    SINK
    
    List
    
    Monadic
    
    Result
    
    Monad
    
    Std
    
    Interfaces
    
    Array
    
    Deque
    
    Int
    
    List
    
    Result
    
    String
    
    String
    
    To_source
    
    From_source
- Sources
  - fmlib
    
    fmlib.ml
  - fmlib.fmlib_parse
    
    buffer.ml
    
    character.ml
    
    character_state.ml
    
    error.ml
    
    fmlib_parse.ml
    
    generic.ml
    
    indent.ml
    
    interfaces.ml
    
    located.ml
    
    position.ml
    
    test_calculator.ml
    
    test_character.ml
  - fmlib.fmlib_pretty
    
    fmlib_pretty.ml
    
    print.ml
    
    state.ml
  - fmlib.fmlib_std
    
    array.ml
    
    deque.ml
    
    fmlib_std.ml
    
    int.ml
    
    interfaces.ml
    
    list.ml
    
    result.ml
    
    string.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Generic.Make`Source

Token.t Token type
State.t Type of the user state
Expect.t Type of syntax messages which are generated, when something has been expected but not found.
Semantic.t Type of semantic error messages. Triggered by fail error.
Final.t Type of the returned object, when parsing has finished.

Parameters

module Token : Fmlib_std.Interfaces.ANY

module State : Fmlib_std.Interfaces.ANY

module Expect : Fmlib_std.Interfaces.ANY

module Semantic : Fmlib_std.Interfaces.ANY

module Final : Fmlib_std.Interfaces.ANY

Signature

Final parser

Sourcemodule Parser : sig ... end

The final parser.

Generic Combinators

include Interfaces.COMBINATOR
  with type state = State.t
   and type expect = Expect.t
   and type semantic = Semantic.t

Sourcetype state = State.t

Sourcetype expect = Expect.t

Sourcetype semantic = Semantic.t

Basic Combinators

Sourcetype _ t

'a t Type of a parse combinator returning an 'a.

Sourceval (>>=) : 'a t -> ('a -> 'b t) -> 'b t

p >>= f

Parse first the input according to the combinator p. In case of success, feed the returned value of p into the function f to get the combinator to parse next.

Sourceval (let*) : 'a t -> ('a -> 'b t) -> 'b t

let* x = p in f x is equivalent to p >>= f

The let* combinator let us express parsing sequences conveniently. Example:

    let* x = p in       (* parse [p], result [x] in case of success. *)
    let* y = q x in     (* parse [q x], result [y] ... *)
    let* z = r x y in   (* ... *)
    ...
    return f x y z ...

The wildcard let* _ = ... can be used to ignore results of intermediate parsing steps.

Sourceval map : ('a -> 'b) -> 'a t -> 'b t

map f p

Try combinator p. In case of success, map the returned value x to f x. In case of failure, do nothing.

map f p is equivalent to let* x = p in return (f x).

Sourceval succeed : 'a -> 'a t

succeed a

Succeed immediately without consuming token. Return object a as result.

Sourceval return : 'a -> 'a t

return a is equivalent to succeed a.

Sourceval unexpected : expect -> 'a t

unexpected expect triggers a syntax error signalling the expectation expect.

Sourceval clear_last_expectation : 'a -> 'a t

clear_last_expectation p Clear last failed expectation.

This is useful e.g. after stripping whitespace. Since stripping whitespace means skip_one_or_more ws or skip_zero_or_more ws, after skipping whitespace the parser can still expect more whitespace. Therefore there is a failed expectation *whitespace* on the stack. However you rarely want this expectation to be reported.

Sourceval fail : semantic -> 'a t

fail error triggers a semantic error.

Sourceval (</>) : 'a t -> 'a t -> 'a t

p </> q

Try first combinator p. In case of success or failure with consumed token, p </> q is equivalent to p.

If p fails without consuming token, then p </> q is equivalent to q.

Sourceval choices : 'a t -> 'a t list -> 'a t

choices p [q r t ...] is equivalent to p </> q </> r </> t </> ....

Sourceval (<?>) : 'a t -> expect -> 'a t

p <?> expect

Try combinator p. In case of success or failure with consumed token, p <?> expect is equivalent to p.

If p fails without consuming token, then the failed expectations are replaced with the failed expectation expect.

Usually p is a combinator implementing a choice between various alternatives of a grammar construct. The <?> combinator allows to replace the set of failed grammar alternatives with a higher abstraction of the failed expectation. E.g. instead of getting the failed expectations identifier, '(', -, ... we can get the failed expectation expression.

State Combinators

Sourceval get : state t

Get the current user state.

Sourceval update : (state -> state) -> unit t

update f Update the user state using f.

Sourceval get_and_update : (state -> state) -> state t

get_and_update f Get the current user state and then update the user state. The returned value is the old state.

Convenience Combinators

Sourceval optional : 'a t -> 'a option t

optional p

Try combinator p.

Success: Return Some a where a is the returned value.
Failure without consuming token: Return None
Failure with consuming token: Remain in the error state.

Sourceval zero_or_more : 'r -> ('item -> 'r -> 'r) -> 'item t -> 'r t

zero_or_more start f p

Try the combinator p as often as possible. Return start if p fails without consuming token. As long as p succeeds use f to accumulate the results.

The first time p fails without consuming token, return the accumulated result.

If p fails by consuming token, then zero_or_more f p fails with the same error.

Sourceval one_or_more : ('item -> 'r) -> ('item -> 'r -> 'r) -> 'item t -> 'r t

one_or_more first next p

one_or_more first next p is equivalent to

    let* x = p in
    zero_or_more (first x) next p

Sourceval list_zero_or_more : 'a t -> 'a list t

list_zero_or_more p Parse zero or more occurrences of p and returned the collected result in a list.

Sourceval list_one_or_more : 'a t -> ('a * 'a list) t

list_zero_or_more p Parse one or more occurrences of p and returned the collected results as a pair of the first value and a list of the remaining values.

Sourceval skip_zero_or_more : 'a t -> int t

skip_zero_or_more p Parse zero or more occurrences of p, ignore the result and return the number of occurrences.

Sourceval skip_one_or_more : 'a t -> int t

skip_one_or_more p Parse one or more occurrences of p, ignore the result and return the number of occurrences.

Source

val one_or_more_separated : 
  ('item -> 'r) ->
  ('r -> 'sep -> 'item -> 'r) ->
  'item t ->
  'sep t ->
  'r t

one_or_more_separated first next p sep

Parse one or more occurrences of p separated by sep. Use first to convert the first occurrence of p into the result and use next to accumulate the results.

Backtracking

Sourceval backtrack : 'a t -> expect -> 'a t

backtrack p expect

Try the combinator p. In case of failure with consuming token, push the consumed token back to the lookahead and let it fail without consuming token. Use expect to record the failed expectation.

Backtracking reduces the performance, because the token pushed back to the lookahead have to be parsed again. Try to avoid backtracking whenever possible.

Sourceval followed_by : 'a t -> expect -> 'a t

followed_by p expect

Parses p and backtracks (i.e. all tokens of p will be pushed back to the lookahead). In case p succeeds, the followed_by parser succeeds without consuming token. Otherwise it fails without consuming tokens.

Sourceval not_followed_by : 'a t -> expect -> unit t

not_followed_by p expect

Parses p and backtracks (i.e. all tokens of p will be pushed back to the lookahead). In case p succeeds, the not_followed_by parser fails without consuming token. Otherwise it succeeds without consuming tokens.

followed_by and not_followed_by can be used to peek into the token stream without consuming token.

Elementary Parsing Step

Source

val step : 
  (State.t -> Token.t option -> ('a * State.t, Expect.t) result) ->
  'a t

step f

Elementary parsing step.

The function f is called with two arguments:

The current state
The next lookahead token (or none, if the end of the token stream has been reached).

f must return either an object of type 'a and a new state if it accepts the token, or a failed expectation if it rejects the token.

Make the Final Parser

Sourceval make : State.t -> Final.t t -> (State.t -> Expect.t) -> Parser.t

make state p e Makes a parser.

state Initial state
p Combinator which returns in case of success an object of type Final.t
e Error function. Generates an expectation from the state. The function is used if at the expected end of input other token arrive.

The generated parser expects a token stream which can be successfully parsed by the combinator p and then it expects the end of input.

Sourceval make_parser : State.t -> Final.t t -> Parser.t

package fmlib

Module Generic.MakeSource

Parameters

Signature

Final parser

Generic Combinators

Basic Combinators

State Combinators

Convenience Combinators

Backtracking

Elementary Parsing Step

Make the Final Parser

Module `Generic.Make`Source