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
Location Combinator
Indentation Combinators
Make the Final Parser
Character Combinators

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 `Character.Make`Source

State: User state.
Final: Final result type of the parser.
Semantic: Semantic error message (triggered by fail error)

Parameters

module State : Fmlib_std.Interfaces.ANY

module Final : Fmlib_std.Interfaces.ANY

module Semantic : Fmlib_std.Interfaces.ANY

Signature

Final Parser

Sourcemodule Parser : sig ... end

Generic Combinators

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

Sourcetype state = State.t

Sourcetype expect = string

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.

Location Combinator

Sourceval located : 'a t -> 'a Located.t t

located p Parse p and return its result with its start and end position.

Note: If p parses strips whitespace at the end, the returned end position is at the end of the whitespace. This is not what you usually want. Therefore first parse the essential part located and then strip the whitespace.

Indentation Combinators

Sourceval indent : int -> 'a t -> 'a t

indent i p Indent p by i columns relative to its parent.

Precondition: 0 <= i

Sourceval align : 'a t -> 'a t

align p

Set the indentation set of p to {col} where col is the column position of its first character. Fail, if col is not in the indentation set.

Sourceval left_align : 'a t -> 'a t

left_align p

Set the indentation set of p to {col} where col is the column position of its first character. Fail, if col is not the lower bound of the indentation set. I.e. p is left aligned in its indentation set.

Sourceval detach : 'a t -> 'a t

detach p Parse p without any indentation and alignment restrictions.

Sourceval zero_or_more_aligned : 'r -> ('a -> 'r -> 'r) -> 'a t -> 'r t

zero_or_more_aligned start next p

Parse an indented block of zero or more aligned constructs p.

Equivalent to

    zero_or_more start next (align p) |> align |> indent 1

Sourceval one_or_more_aligned : ('a -> 'r) -> ('a -> 'r -> 'r) -> 'a t -> 'r t

zero_or_more_aligned first next p

Parse an indented block of one or more aligned constructs p.

Equivalent to

    one_or_more first next (align p) |> align |> indent 1

Make the Final Parser

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

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

Character Combinators

Sourceval charp : (char -> bool) -> string -> char t

Sourceval char : char -> char t

Sourceval one_of_chars : string -> expect -> char t

Sourceval string : string -> string t

Sourceval uppercase_letter : char t

Sourceval lowercase_letter : char t

Sourceval letter : char t

Sourceval digit : int t

package fmlib

Module Character.MakeSource

Parameters

Signature

Final Parser

Generic Combinators

Basic Combinators

State Combinators

Convenience Combinators

Backtracking

Location Combinator

Indentation Combinators

Make the Final Parser

Character Combinators

Module `Character.Make`Source