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/Simple/index.html

Module `Character_parser.Simple`

Simple Parser.

Parameters

module Final : Module_types.ANY

Signature

Modules and Types

module Context : CONTEXT with type msg = string

module Error : 
  Generic_parser.ERROR with type expect = string and type semantic = string

type final = Final.t

type token = char option

Combinators

include COMBINATORS
  with type expect = string
   and type semantic = string
   and type state = Common.Unit.t
   and type context = string

Basic Combinators

include Generic_parser.COMBINATORS
  with type expect = string
  with type semantic = string

type 'a t

type expect = string

type semantic = string

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 = Common.Unit.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 = string

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

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

Character Combinators

val expect_end : unit t

val whitespace_char : char t

val whitespace : int t

val one_of_chars : string -> expect -> unit t

val string : string -> unit t

val char : char -> unit t

val space : unit t

val letter : char t

val digit : 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.

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 result_string : parser -> (final -> string) -> string

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.

val lookahead_string : parser -> string

Create and Run the Parser

val make : final t -> parser

make pc makes a parser from a parser combinator pc.

val run : final t -> string -> parser

run p str makes a parser from the combinator pc and runs the parser on the string str.

On This Page

Parameters
Signature
Modules and Types
Combinators
Parser