package orsetto

  1. Overview
  2. Docs
A library of assorted structured data interchange languages

Install 

dune-project
 Dependency

bitbucket.org Edit opam file Versions (8)

Authors

  1. J
    james woodyatt <jhw@conjury.org>

Maintainers

  1. J
    james woodyatt <jhw@conjury.org>

Sources

r1.0.tar.gz
sha256=585297372d7f6cfb830214e9ef22d6d072a39b2a1591ef90f1ee2bcfe144cad3
md5=6bb6a7ba88bf2c7595a0b332921e60b4

doc/orsetto.cf/Cf_dfa/Create/index.html

Module Cf_dfa.Create

Use Create(B) to make the DFA module for B including its optional affix operators.

Parameters

module B : Basis

Signature

include Regular with type event := B.Event.t
type term

The type of a regular language term.

val nil : term

The empty term, representing no events.

val one : B.Event.t -> term

Use one v to make a term representing the single occurrence of v.

val sat : (B.Event.t -> bool) -> term

Use sat f to make a term representing any event that satisfies the predicate f.

val cat2 : term -> term -> term

Use cat2 a b to make a term representing a and b concatenated.

val cats : term Seq.t -> term

Use cats s to make a term representing the concatenation of all the terms of s in sequential order.

val alt2 : term -> term -> term

Use alt2 a b to make a term representing the occurrence of either a or b.

val alts : term Seq.t -> term

Use alts s to make a term representing the occurrence of any of the alternatives in s.

val opt : term -> term

Use opt t to make a term representing either zero or one occurences of t.

val star : term -> term

Use star t to make a term representing the Kleene star of t, i.e. zero, one or more occurrences of t.

val seq : ?a:int -> ?b:int -> term -> term

Use seq t to make a term representing a sequence of occurrences of t.

If ~a is used, then it specifies the minimum number of occurrences in the recognized sequence. If ~b is used then it specifies the maximum number of occurrences in the recognized sequence. Composition raises Invalid_argument if a < 0 or b < a.

type 'r fin

The type of a final state.

val fin : term -> 'a -> 'a fin

Use fin t r to make t into a final state identified by r

include Machine with type event := B.Event.t and type 'r fin := 'r fin
type 'r t

The type of automatons parameterized by final identifier type. An imperative programming interface is provided below for elaboration.

val create : 'r fin Seq.t -> 'r t

Use create s to make a new DFA with all the final states of s.

val copy : 'r t -> 'r t

Use copy dfa to copy the internal state of dfa into a new machine, ready to advance from the same point.

val reset : 'r t -> unit

Use reset dfa to reset the internal state of dfa to its initial state, ready to advance on new events.

val advance : 'r t -> B.Event.t -> unit

Use advance dfa event to advance dfa with event. Raises Failure if dfa has rejected an event previously.

val rejected : 'r t -> bool

Use finished dfa to check whether dfa has rejected an event and and may not be advanced any further.

val accepted : 'r t -> bool

Use accepted dfa to check whether dfa has reached a final state. A DFA may still be further advanced after reaching one of its final states the first time.

val finish : 'r t -> 'r

Use finish dfa to get the final value dfa. Raise Not_found if no final value is available, i.e. either because it has rejected an event or it has not yet reached an accepting state.

module Affix : Affix with type event := B.Event.t and type term := term and type 'r fin := 'r fin