Forlan Manual

Top-level Environment

Version

Identifier	Value
`val getVersion : unit -> string`	`Version.getVersion`

Parameters

Identifier	Value
`val getSearchPath : unit -> string list`	`Params.getSearchPath`
`val setSearchPath : string list -> unit`	`Params.setSearchPath`
`val getWorkingDirectory : unit -> string`	`Params.getWorkingDirectory`
`val setWorkingDirectory : string -> unit`	`Params.setWorkingDirectory`
`val getPrintingListLength : unit -> int`	`Params.getPrintingListLength`
`val setPrintingListLength : int -> unit`	`Params.setPrintingListLength`
`val getPrintingStringSize : unit -> int`	`Params.getPrintingStringSize`
`val setPrintingStringSize : int -> unit`	`Params.setPrintingStringSize`
`val getPrintingDataStructureDepth : unit -> int`	`Params.getPrintingDataStructureDepth`
`val setPrintingDataStructureDepth : int -> unit`	`Params.setPrintingDataStructureDepth`
`val getPrintingLineLength : unit -> int`	`Params.getPrintingLineLength`
`val setPrintingLineLength : int -> unit`	`Params.setPrintingLineLength`
`val setPrintingOfGarbageCollectionMessages : bool -> unit`	`Params.setPrintingOfGarbageCollectionMessages`
`val getTrackExceptions : unit -> bool`	`Params.getTrackExceptions`
`val setTrackExceptions : bool -> unit`	`Params.setTrackExceptions`

Debugging

Identifier	Value
`val debug : ('a -> PP.pp) -> PP.pp * 'a -> 'a`	`Debug.debug`

Using Files

Identifier	Value
`val use : string -> unit`	`Use.use`

Basic Types

Identifier	Value
`type 'a set`	`'a Set.set`
`type sym`	`Sym.sym`
`type str`	`Str.str`
`type ('a, 'b)rel`	`('a, 'b)Rel.rel`
`type sym_rel`	`SymRel.sym_rel`

Note that

sym and Sym.sym are equal to Lex.sym;
str and Str.str are equal to sym list;
('a, 'b)rel and ('a, 'b)Rel.rel are equal to ('a * 'b)set;
sym_rel and SymRel.sym_rel are equal to (sym, sym)rel, which is equal to (sym * sym)set.

Conversions Between Basic Types and Strings

Identifier	Value
`val stringToSym : string -> sym`	`Sym.fromString`
`val symToString : sym -> string`	`Sym.toString`
`val stringToStr : string -> str`	`Str.fromString`
`val strToString : str -> string`	`Str.toString`
`val stringToSymSet : string -> sym set`	`SymSet.fromString`
`val symSetToString : sym set -> string`	`SymSet.toString`
`val stringToStrSet : string -> str set`	`StrSet.fromString`
`val strSetToString : str set -> string`	`StrSet.toString`
`val stringToSymRel : string -> sym_rel`	`SymRel.fromString`
`val symRelToString : sym_rel -> string`	`SymRel.toString`

Regular Expressions

Identifier	Value
`type reg`	`Reg.reg`
`val stringToReg : string -> reg`	`Reg.fromString`
`val regToString : reg -> string`	`Reg.toString`
`val symToReg : sym -> reg`	`Reg.fromSym`
`val strToReg : str -> reg`	`Reg.fromStr`

Labeled Paths

Identifier	Value
`type lp`	`LP.lp`
`val stringToLP : string -> lp`	`LP.fromString`
`val lpToString : lp -> string`	`LP.toString`

Finite Automata

Identifier	Value
`type tran`	`Tran.tran`
`type fa`	`FA.fa`
`type efa`	`EFA.efa`
`type nfa`	`NFA.nfa`
`type dfa`	`DFA.dfa`
`val symToNFA : sym -> nfa`	`NFA.fromSym`
`val symToEFA : sym -> efa`	`EFA.fromSym`
`val symToFA : sym -> fa`	`FA.fromSym`
`val strToFA : str -> fa`	`FA.fromStr`

Injections and Projections Between Finite Automata

Identifier	Value
`val injDFAToNFA : dfa -> nfa`	`DFA.injToNFA`
`val injDFAToEFA : dfa -> efa`	`DFA.injToEFA`
`val injDFAToFA : dfa -> fa`	`DFA.injToFA`
`val injNFAToEFA : nfa -> efa`	`NFA.injToEFA`
`val injNFAToFA : nfa -> fa`	`NFA.injToFA`
`val injEFAToFA : efa -> fa`	`EFA.injToFA`
`val projNFAToDFA : nfa -> dfa`	`DFA.projFromNFA`
`val projEFAToDFA : efa -> dfa`	`DFA.projFromEFA`
`val projFAToDFA : fa -> dfa`	`DFA.projFromFA`
`val projEFAToNFA : efa -> nfa`	`NFA.projFromEFA`
`val projFAToNFA : fa -> nfa`	`NFA.projFromFA`
`val projFAToEFA : fa -> efa`	`EFA.projFromFA`

Conversions Between Finite Automata

Identifier	Value
`val nfaToDFA : nfa -> dfa`	`DFA.fromNFA`
`val efaToNFA : efa -> nfa`	`NFA.fromEFA`
`val faToEFA : fa -> efa`	`EFA.fromFA`

Conversions Between Finite Automata and Regular Expressions

Identifier	Value
`val regToFA : reg -> fa`	`FA.fromReg`
`val faToRegTrace : (int option * (reg -> reg)) -> fa -> reg`	`RFA.faToRegTrace`
`val faToReg : (int option * (reg -> reg)) -> fa -> reg`	`RFA.faToReg`

Regular Expression Finite Automata

Identifier	Value
`type tran_reg`	`TranReg.tran_reg`
`type rfa`	`RFA.rfa`

Parse Trees

Identifier	Value
`type pt`	`PT.pt`
`val stringToPT : string -> pt`	`PT.fromString`
`val ptToString : pt -> string`	`PT.toString`

Grammars

Identifier	Value
`type prod`	`Prod.prod`
`type gram`	`Gram.gram`
`val symToGram : sym -> gram`	`Gram.fromSym`
`val strToGram : str -> gram`	`Gram.fromStr`
`val faToGram : fa -> gram`	`Gram.fromFA`
`val regToGram : reg -> gram`	`Gram.fromReg`

Programs

Identifier	Value
`type var`	`Var.var`
`type prog`	`Prog.prog`
`type cp`	`Prog.cp`
`val progToClosedProg : prog -> cp`	`Prog.toClosed`
`val closedProgToProg : cp -> closed`	`Prog.fromClosed`

[ Top | Parent | Root | Contents | Index ]

Forlan Version 3.5
Copyright © 2000-2009 Alley Stoughton