package fmlib

You can search for identifiers within the package.

in-package search v0.2.0

package fmlib

fmlib
- Fmlib
fmlib.fmlib_parse
- Fmlib_parse
  - Buffer
    
    Make
    
    Error
    
    Expect
    
    Semantic
    
    State
    
    Token
  - Character
    
    Make
    
    Final
    
    Parser
    
    Semantic
    
    State
  - Character_state
    
    Make
    
    User
  - Error
    
    Make
    
    Expect
    
    Semantic
  - Generic
    
    Make
    
    Expect
    
    Final
    
    Parser
    
    Semantic
    
    State
    
    Token
  - Indent
  - Interfaces
    
    COMBINATOR
    
    PARSER
  - Located
  - Parse
  - Position
  - Test_calculator
    
    CP
    
    Parser
  - Test_character
    
    CP
    
    Parser
    
    Indent_sensitive
    
    Basic
    
    Parser
    
    Final
    
    SP
    
    Parser
fmlib.fmlib_pretty
- Fmlib_pretty
  - Pretty
  - Print
  - State
    
    Buffer
    
    Chunk
    
    Group
    
    Line
    
    Text
fmlib.fmlib_std
- Fmlib_std
  - Array
  - Deque
  - Int
  - Interfaces
    
    ANY
    
    MONAD
    
    SINK
    
    SORTABLE
    
    SOURCE
  - List
    
    Monadic
    
    M
  - Result
    
    Monad
    
    E
  - Std
  - String
    
    From_source
    
    S
    
    To_source

Legend:
Library
Module
Module type
Parameter
Class
Class type

module Parser : sig ... end

type state = Unit.t

type expect = string

type semantic = String.t

type 'a t

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

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

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

val succeed : 'a -> 'a t

val return : 'a -> 'a t

val unexpected : expect -> 'a t

val clear_last_expectation : 'a -> 'a t

val fail : semantic -> 'a t

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

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

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

val get : state t

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

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

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

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

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

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

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

val skip_zero_or_more : 'a t -> int t

val skip_one_or_more : 'a t -> int t

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

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

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

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

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

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

val align : 'a t -> 'a t

val left_align : 'a t -> 'a t

val detach : 'a t -> 'a t

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

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

val make : Unit.t -> Int.t t -> Parser.t

val make_parser : Position.t -> Unit.t -> Int.t t -> Parser.t

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

val char : char -> char t

val one_of_chars : string -> expect -> char t

val string : string -> string t

val uppercase_letter : char t

val lowercase_letter : char t

val letter : char t

val digit : int t