package alba

You can search for identifiers within the package.

in-package search v0.2.0

Alba compiler

Install

Dune Dependency

albatross-lang.sourceforge.net Readme Edit opam file Versions (5)

Authors

H

Helmut Brandl <helmut.brandl@gmx.net>

Maintainers

H

Helmut Brandl <helmut.brandl@gmx.net>

Sources

0.4.1.tar.gz

sha256=439b1dce07c86e914d1ebf1712c5581418314b0c8d13594f27a698b1d25fe272

md5=5cf58d4ed4eacbe6f330e9d2378ef5c6

doc/alba.fmlib/Fmlib/Character_parser/Advanced/index.html

Module `Character_parser.Advanced`

Advanced Parser.

Parameters

module State : Module_types.ANY

module Final : Module_types.ANY

module Expect : Module_types.ANY

module Semantic : Module_types.ANY

module Context_msg : Module_types.ANY

Signature

Modules and Types

module Context : CONTEXT with type msg = Context_msg.t

module Error : 
  Generic_parser.ERROR
    with type expect = Expect.t
     and type semantic = Semantic.t

type final = Final.t

type token = char option

Combinators

include COMBINATORS
  with type expect = Expect.t
   and type semantic = Semantic.t
   and type state = State.t
   and type context = Context_msg.t

Basic Combinators

include Generic_parser.COMBINATORS
  with type expect = Expect.t
  with type semantic = Semantic.t

type 'a t

type expect = Expect.t

type semantic = Semantic.t

val return : 'a -> 'a t

val succeed : 'a -> 'a t

val unexpected : expect -> 'a t

val fail : semantic -> 'a t

val consumer : 'a t -> 'a t

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

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

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

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

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

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

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

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

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

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

val one_or_more_separated : 'a t -> _ t -> 'a list t

val zero_or_more_separated : 'a t -> _ t -> 'a list t

val skip_zero_or_more : 'a t -> int t

val skip_one_or_more : 'a t -> int t

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

val (|.) : 'a t -> _ t -> 'a t

Position and State Combinators

val get_position : Position.t t

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

type state = State.t

val get_state : state t

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

Indentation Combinators

val absolute : 'a t -> 'a t

val indented : bool -> 'a t -> 'a t

val detached : 'a t -> 'a t

val get_bounds : (int * int option) t

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

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

val skip_one_or_more_aligned : 'a t -> int t

val skip_zero_or_more_aligned : 'a t -> int t

Context Combinator

type context = Context_msg.t

val in_context : context -> 'a t -> 'a t

Character Combinators

val expect : (char -> bool) -> expect -> char t

val expect_end : expect -> unit t

val whitespace_char : expect -> char t

val whitespace : expect -> int t

val one_of_chars : string -> expect -> unit t

val string : string -> (int -> expect) -> unit t

val char : char -> expect -> unit t

val space : expect -> unit t

val letter : expect -> char t

val digit : expect -> char t

val word : (char -> bool) -> (char -> bool) -> expect -> string t

Parser

During Parsing

include PARSER

type parser

Parser Type

val needs_more : parser -> bool

Does the parser need more tokens (i.e. either put_char or put_end)?

val has_ended : parser -> bool

Has the parser terminated (opposite of needs_more p)?

val has_succeeded : parser -> bool

Has the parser succeeded

val position : parser -> Position.t

The current position.

val line : parser -> int

The current line.

val column : parser -> int

The current column.

val put_char : parser -> char -> parser

put_char p c feeds the parser p with the character token c. Only possible if needs_more p is valid.

val put_end : parser -> parser

put_end p signals to the parser p the end of stream. Only possible if needs_more p is valid.

val state : parser -> State.t

The state of the parser.

Terminated Parser

val result : parser -> final option

The result the parser has produced which is either a final value or a list of dead ends. Only valid if the parser has terminated.

val error : parser -> Error.t

val lookahead : parser -> token list

The list of tokens (i.e. optional characters) which the parser has not processed at the point of termination.

Create and Run the Parser

val make : final t -> State.t -> parser

make pc st makes a parser from a parser combinator pc and the initial state st.

val run : final t -> State.t -> string -> parser

run pc st str makes a parser from the combinator pc and the initial state st and runs the parser on the string str.

On This Page

Parameters
Signature
Modules and Types
Combinators
1. Character Combinators
Parser