Forlan Manual

Unified identifier index

A

`Accept, PROG`		`adjacentElts, LIST_AUX`		`Ans, PROG`
`accept, PROG`		`all, SET`		antisymmetric
`accept, PROG`		allButLast			`REL`
accepted			`LIST_AUX`		`SYM_REL`
	`DFA`		`STR`	`App, PROG`
	`EFA`	`allSplittings, LIST_AUX`		`app, PROG`
	`FA`	`allStr, REG`		apply
	`NFA`	`allSym, REG`			`REL`
	`PROG`	alphabet			`SYM_REL`
acceptingStates			`DFA`	applyFunction
	`DFA`		`EFA`		`REL`
	`EFA`		`FA`		`SYM_REL`
	`FA`		`GRAM`
	`NFA`		`NFA`
	`RFA`		`REG`
			`RFA`
			`STR`
			`STR_SET`

B

`Bar, LEX`		`beginsWithVar, VAR`		bijectionFromTo
`Basic, SYM`		bijectionFromAvoiding			`REL`
basic			`REL`		`SYM_REL`
	`LEX`		`SYM_REL`	`block, PP`
	`SYM`	bijectionFromSupersetAvoiding
`BasicSymTop, LEX`			`REL`
basicToChar			`SYM_REL`
	`LEX`
	`SYM`

C

`Calc, PROG`		`compareCC, REG`		cons
`calc, PROG`		`compareComplexity, REG`			`LP`
`CannotHappen, MESSAGES`		`compareComplexityTotal, REG`			`PT`
`cannotHappen, MESSAGES`		`compareList, SET`		`ConsSym, PROG`
`cc, REG`		comparePair		`Const, PROG`
`cc, REG`			`SET`	`const, PROG`
`ccToList, REG`			`SYM_REL`	`const, PROG`
charToBasic		`compareSym, LEX`		`cp, PROG`
	`LEX`	`compareTriple, SET`
	`SYM`	`complement, DFA`
`checkInLabToks, LEX`		compose
checkLP			`REL`
	`DFA`		`SYM_REL`
	`EFA`	`Compound, SYM`
	`FA`	`CompoundSymTop, LEX`
	`NFA`	`Concat, REG`
	`RFA`	concat
`checkPT, GRAM`			`EFA`
checkPumpingDivision			`FA`
	`LP`		`GRAM`
	`PT`		`REG`
`chomskyNormalForm, GRAM`			`STR_SET`
`ClosPar, LEX`		`concatsToList, REG`
`Closure, REG`		concr
closure			`FA`
	`EFA`		`GRAM`
	`FA`		`LP`
	`GRAM`		`PROG`
	`REG`		`PT`
`colon, PP`			`REG`
`Comma, LEX`			`RFA`
`comma, PP`		`Cond, PROG`
`Compare, PROG`		`cond, PROG`
compare		`Cons, LP`
	`DFA`
	`EFA`
	`FA`
	`GRAM`
	`LP`
	`NFA`
	`PROD`
	`PROD_SET`
	`PROG`
	`PT`
	`REG`
	`RFA`
	`SET`
	`STR`
	`STR_SET`
	`SYM`
	`SYM_REL`
	`SYM_SET`
	`TRAN`
	`TRAN_REG`
	`TRAN_REG_SET`
	`TRAN_SET`
	`VAR`
	`VAR_SET`

D

deadStates		`DeconsSym, PROG`	`dfa, DFA`
	`DFA`	`decorate, PP`	`Dollar, LEX`
	`EFA`	`determAccepted, DFA`	domain
	`FA`	`determProcessStr, DFA`		`REL`
	`NFA`	`determSimplified, DFA`		`SYM_REL`
`DEBUG`		`determSimplify, DFA`		`TAB`
`Debug`		`determTransitionFun, DFA`	`DoubArr, LEX`
`debug, DEBUG`		`DFA`
`decons, PT`		`DFA`

E

`EFA`		`EmptyStr, REG`		`equalTok, LEX`
`EFA`		emptyStr		`equivalent, DFA`
`efa, EFA`			`DFA`	`Error, MESSAGES`
`eliminateEmptyAndUnitProductions, GRAM`			`EFA`	`Error, PROG`
`eliminateEmptyProductions, GRAM`			`FA`	`error, LEX`
`eliminateState, RFA`			`GRAM`	`errorNotEOFTerminated, LEX`
`eliminateVariable, GRAM`			`NFA`	`errorPP, MESSAGES`
`eliminateVariableConstraints, GRAM`			`REG`	`errorString, MESSAGES`
`eliminateVariableConstraintsOpt, GRAM`		`endState, LP`		`evaluate, PROG`
`eliminateVariableOpt, GRAM`		`EOF, LEX`		`exists, SET`
empty		`Equal, DFA`		`expectedDigit, LEX`
	`PP`	equal		`expectedLetter, LEX`
	`SET`		`DFA`	`expectedLetterOrDigit, LEX`
	`TAB`		`EFA`	`expectedTok, LEX`
emptyClose			`FA`
	`EFA`		`GRAM`
	`FA`		`LP`
emptyCloseBackwards			`NFA`
	`EFA`		`PROD`
	`FA`		`PROD_SET`
`EmptySet, REG`			`PROG`
emptySet			`PT`
	`DFA`		`REG`
	`EFA`		`RFA`
	`FA`		`SET`
	`GRAM`		`SORT`
	`NFA`		`STR`
	`REG`		`STR_SET`
			`SYM`
			`SYM_REL`
			`SYM_SET`
			`TRAN`
			`TRAN_REG`
			`TRAN_REG_SET`
			`TRAN_SET`
			`VAR`
			`VAR_SET`

F

`FA`		findValidPumpingDivision		fromString
`FA`			`LP`		`DFA`
`fa, FA`			`PT`		`EFA`
`Fail, PROG`		findValidPumpingDivisionOpt			`FA`
`False, PROG`			`LP`		`GRAM`
`faToReg, RFA`			`PT`		`LP`
`faToRegPerms, RFA`		`free, PROG`			`NFA`
`faToRegPermsTrace, RFA`		`fromClosed, PROG`			`PP`
`filter, SET`		fromConcr			`PROD_SET`
findAcceptingLP			`FA`		`PROG`
	`DFA`		`GRAM`		`PT`
	`EFA`		`LP`		`REG`
	`FA`		`PROG`		`RFA`
	`NFA`		`PT`		`STR`
findAcceptingLPOpt			`REG`		`STR_SET`
	`DFA`		`RFA`		`SYM`
	`EFA`	`fromEFA, NFA`			`SYM_REL`
	`FA`	fromFA			`SYM_SET`
	`NFA`		`EFA`		`TRAN_REG_SET`
findIsomorphism			`GRAM`		`TRAN_SET`
	`DFA`		`RFA`		`VAR`
	`EFA`	fromList			`VAR_SET`
	`FA`		`PROD_SET`	`fromStringSplitEscape, PP`
	`GRAM`		`SET`	fromStrSet
	`NFA`		`STR_SET`		`GRAM`
findIsomorphismOpt			`SYM_REL`		`REG`
	`DFA`		`SYM_SET`	fromSym
	`EFA`		`TAB`		`EFA`
	`FA`		`TRAN_REG_SET`		`FA`
	`GRAM`		`TRAN_SET`		`GRAM`
	`NFA`		`VAR_SET`		`NFA`
findLP		`fromNFA, DFA`			`REG`
	`DFA`	fromReg		`fromTo, LIST_AUX`
	`EFA`		`FA`	`fromTop, SYM`
	`FA`		`GRAM`	`Fst, PROG`
	`NFA`	`fromRep, PROG`		function
findLPOpt		fromStr			`REL`
	`DFA`		`FA`		`SYM_REL`
	`EFA`		`GRAM`	functionFromTo
	`FA`		`PROG`		`REL`
	`NFA`		`REG`		`SYM_REL`

G

genConcat		`genTimes, SET`		`getPrintingLineLength, PARAMS`
	`EFA`	genUnion		`getPrintingListLength, PARAMS`
	`FA`		`EFA`	`getPrintingStringSize, PARAMS`
	`GRAM`		`FA`	`getSearchPath, PARAMS`
	`REG`		`GRAM`	`getSMLNJVersion, VERSION`
`generated, GRAM`			`PROD_SET`	`getTrackExceptions, PARAMS`
`generatedFromVariable, GRAM`			`REG`	`getVersion, VERSION`
genInter			`SET`	`getWorkingDirectory, PARAMS`
	`DFA`		`STR_SET`	`globallySimplified, REG`
	`EFA`		`SYM_REL`	`globallySimplify, REG`
	`NFA`		`SYM_SET`	`globallySimplifyTrace, REG`
	`PROD_SET`		`TRAN_REG_SET`	`GRAM`
	`SET`		`TRAN_SET`	`Gram`
	`STR_SET`		`VAR_SET`	`gram, GRAM`
	`SYM_REL`	`getBindNonExhaustiveWarn, PARAMS`
	`SYM_SET`	`getCompilationManagerVerbosity, PARAMS`
	`TRAN_REG_SET`	`getPrintingDataStructureDepth, PARAMS`
	`TRAN_SET`
	`VAR_SET`

H

`hasEmp, REG`	`hd, SET`
`hasNoEmptyOrUnitProductions, GRAM`	`Heading, LEX`
`hasNoEmptyProductions, GRAM`	height
`hasSym, REG`		`PROG`
		`PT`
		`REG`

I

`inChomskyNormalForm, GRAM`		inputFromLabToks		`isConcat, REG`
`Incomp, DFA`			`PROD_SET`	isEmpty
injection			`REG`		`SET`
	`REL`		`STR`		`TAB`
	`SYM_REL`		`STR_SET`	`isEmptySet, REG`
injToEFA			`SYM`	`isEmptyStr, REG`
	`DFA`		`SYM_REL`	`IsInt, PROG`
	`NFA`		`SYM_SET`	`IsLam, PROG`
injToFA			`TRAN_REG_SET`	`IsNeg, PROG`
	`DFA`		`TRAN_SET`	`IsNil, PROG`
	`EFA`		`VAR_SET`	`isNonEmpty, SET`
	`NFA`	`inputLabFromLabToks, VAR`		isomorphic
`injToNFA, DFA`		`insert, SORT`			`DFA`
input		`Int, PROG`			`EFA`
	`DFA`	`int, PROG`			`FA`
	`EFA`	inter			`GRAM`
	`FA`		`DFA`		`NFA`
	`GRAM`		`EFA`	isomorphism
	`LP`		`GRAM`		`DFA`
	`NFA`		`NFA`		`EFA`
	`PROD_SET`		`PROD_SET`		`FA`
	`PROG`		`SET`		`GRAM`
	`PT`		`STR_SET`		`NFA`
	`REG`		`SYM_REL`	`IsPair, PROG`
	`RFA`		`SYM_SET`	`IsPos, PROG`
	`STR`		`TRAN_REG_SET`	`isRep, PROG`
	`STR_SET`		`TRAN_SET`	`IsStr, PROG`
	`SYM`		`VAR_SET`	`IsSym, PROG`
	`SYM_REL`	`Intermed, PROG`		`isSym, REG`
	`SYM_SET`	inverse		`isUnion, REG`
	`TRAN_REG_SET`		`REL`	`isValue, PROG`
	`TRAN_SET`		`SYM_REL`	`IsZero, PROG`
	`VAR`	`isClosure, REG`
	`VAR_SET`

J

jforlanEdit		jforlanPretty		`join, LP`
	`FA`		`FA`
	`PROG`		`PROG`
	`PT`		`PT`
	`REG`		`REG`
	`RFA`		`RFA`
jforlanNew			`STR`
	`FA`		`SYM`
	`PROG`	jforlanValidate
	`PT`		`FA`
	`REG`		`PROG`
	`RFA`		`PT`
			`REG`
			`RFA`
			`STR`
			`SYM`

L

`label, LP`	`letSimp, PROG`		`locallySimplified, REG`
`Lam, PROG`	`LEX`		`locallySimplify, REG`
`lam, PROG`	`Lex`		`locallySimplifyTrace, REG`
`last, STR`	`lexFile, LEX`		`localSimplificationRelations, REG`
`leaf, PT`	`lexString, LEX`		`lookup, TAB`
`length, LP`	`LIST_AUX`		`LP`
`less, SORT`	`ListAux`		`LP`
`lessEqual, SORT`	liveStates		`lp, LP`
`LetRec, PROG`		`DFA`
`letRec, PROG`		`EFA`
`LetSimp, PROG`		`FA`
		`NFA`

M

`makeBijectionFromAvoiding, SYM_REL`		`mapToList, SET`		`messageString, MESSAGES`
`makeTempFile, SYSTEM`		`max, LIST_AUX`		`min, LIST_AUX`
map		maximumLengthPath		`minimize, DFA`
	`PROD_SET`		`PROG`	`Minus, PROG`
	`SET`		`PT`	minus
	`STR_SET`		`REG`		`DFA`
	`SYM_REL`	memb			`GRAM`
	`SYM_SET`		`PROD_SET`		`PROD_SET`
	`TRAN_REG_SET`		`SET`		`SET`
	`TRAN_SET`		`STR_SET`		`STR_SET`
	`VAR_SET`		`SYM_REL`		`SYM_REL`
mapFromList			`SYM_SET`		`SYM_SET`
	`PROD_SET`		`TRAN_REG_SET`		`TRAN_REG_SET`
	`SET`		`TRAN_SET`		`TRAN_SET`
	`STR_SET`		`VAR_SET`		`VAR_SET`
	`SYM_REL`	`merge, SORT`		mlFunctionToFunction
	`SYM_SET`	`messagePP, MESSAGES`			`REL`
	`TRAN_REG_SET`	`MESSAGES`			`SYM_REL`
	`TRAN_SET`	`Messages`
	`VAR_SET`

N

`newline, PP`		`numProductions, GRAM`		`numVariables, GRAM`
`Next, PROG`		numStates
`NFA`			`DFA`
`NFA`			`EFA`
`nfa, NFA`			`FA`
`Nil, PROG`			`NFA`
`Node, PT`			`RFA`
`nullableVariables, GRAM`		`numSyms, REG`
`numConcats, REG`		numTransitions
numLeaves			`DFA`
	`PROG`		`EFA`
	`PT`		`FA`
	`REG`		`NFA`
			`RFA`

O

`obviousSubset, REG`
`OpenPar, LEX`
`oper, PROG`
output
	`DFA`
	`EFA`
	`FA`
	`GRAM`
	`LP`
	`NFA`
	`PROD_SET`
	`PROG`
	`PT`
	`REG`
	`RFA`
	`STR`
	`STR_SET`
	`SYM`
	`SYM_REL`
	`SYM_SET`
	`TRAN_REG_SET`
	`TRAN_SET`
	`VAR`
	`VAR_SET`

P

`Pair, PROG`		`PP`		`PROG`
`pair, PROG`		`PP`		`Prog`
`PARAMS`		`pp, PP`		`prog, PROG`
`Params`		prefix		projFromEFA
`parsable, GRAM`			`EFA`		`DFA`
`parse, GRAM`			`GRAM`		`NFA`
`parseAlphabet, GRAM`			`NFA`	projFromFA
`parseAlphabetFromVariable, GRAM`			`REG`		`DFA`
`parseAlphabetFromVariableOpt, GRAM`			`STR`		`EFA`
`parseAlphabetOpt, GRAM`			`STR_SET`		`NFA`
`parseOpt, GRAM`		`prefixes, STR_SET`		`projFromNFA, DFA`
`partition, SET`		processStr		`ProperSub, DFA`
`Perc, LEX`			`DFA`	`ProperSup, DFA`
Plus			`EFA`	`PT`
	`LEX`		`FA`	`PT`
	`PROG`		`NFA`	`pt, PT`
position		`PROD`		pumping_division
	`LIST_AUX`	`Prod`			`LP`
	`SET`	`prod, PROD`			`PT`
`possBeginsWithStr, STR`		`prod, LIST_AUX`		pumpValidPumpingDivision
power		`PROD_SET`			`LP`
	`REG`	`ProdSet`			`PT`
	`STR`	`productions, GRAM`
	`STR_SET`

Q

quiet, MESSAGES

quote, PP

R

range		`RejectWithFalse, PROG`		renameStatesCanonically
	`REL`	`REL`			`DFA`
	`SYM_REL`	`Rel`			`EFA`
`reachableFrom, GRAM`		`rel, REL`			`FA`
`reachableFromBackwards, GRAM`		`relation, DFA`			`NFA`
reachableStates		relationFromTo			`RFA`
	`DFA`		`REL`	`renameVariables, GRAM`
	`EFA`		`SYM_REL`	`renameVariablesCanonically, GRAM`
	`FA`	relationOn		`repeat, LIST_AUX`
	`NFA`		`REL`	`restart, GRAM`
reachified			`SYM_REL`	`restartOpt, GRAM`
	`FA`	`relationship, DFA`		restrictFunction
	`GRAM`	`relationship, DFA`			`REL`
`reachify, GRAM`		`removePrefix, STR`			`SYM_REL`
reflexive		`removeSuffix, STR`		rev
	`REL`	`removeWhiteSpace, STRING_AUX`			`EFA`
	`SYM_REL`	renameAlphabet			`FA`
reflexiveClosure			`DFA`		`GRAM`
	`REL`		`EFA`		`REG`
	`SYM_REL`		`FA`		`STR_SET`
reflexiveTransitiveClosure			`GRAM`	`RFA`
	`REL`		`NFA`	`RFA`
	`SYM_REL`		`REG`	`rfa, RFA`
reflexiveTransitiveSymmetricClosure			`STR`	`rightConcat, REG`
	`REL`		`STR_SET`	`rightUnion, REG`
	`SYM_REL`	renameStates		`rootLabel, PT`
`REG`			`DFA`	`run, PROG`
`Reg`			`EFA`	`run, PROG`
`reg, REG`			`FA`	`runJForlan, SYSTEM`
`RejectOtherwise, PROG`			`NFA`
			`RFA`

S

select		`standard, RFA`		`subst, PROG`
	`PROG`	`standardize, RFA`		`substr, STR`
	`REG`	`standardized, REG`		`substring, STR_SET`
`selectPT, PT`		`Star, LEX`		`substrings, STR_SET`
`Semicolon, LEX`		startState		`succCC, REG`
`semicolon, PP`			`DFA`	suffix
`SET`			`EFA`		`STR`
`Set`			`FA`		`STR_SET`
`set, SET`			`LP`	`suffixes, STR_SET`
`setBindNonExhaustiveWarn, PARAMS`			`NFA`	`sum, LIST_AUX`
`setCompilationManagerVerbosity, PARAMS`			`RFA`	`SYM`
`setPrintingDataStructureDepth, PARAMS`		`startVariable, GRAM`		`Sym`
`setPrintingLineLength, PARAMS`		states		Sym
`setPrintingListLength, PARAMS`			`DFA`		`LEX`
`setPrintingOfGarbageCollectionMessages, PARAMS`			`EFA`		`LP`
`setPrintingStringSize, PARAMS`			`FA`		`PROG`
`setSearchPath, PARAMS`			`NFA`		`REG`
`setTrackExceptions, PARAMS`			`RFA`	sym
`setWorkingDirectory, PARAMS`		`step, PROG`			`LEX`
simplified		`step, PROG`			`SYM`
	`EFA`	`STR`		sym
	`FA`	`Str`			`LP`
	`GRAM`	`Str, PROG`			`PROG`
	`NFA`	`str, STR`		`SYM_REL`
simplify		`str, PROG`		`sym_rel, SYM_REL`
	`EFA`	`STR_SET`		`SYM_SET`
	`FA`	`STRING_AUX`		`sym_top, LEX`
	`GRAM`	`StringAux`		`SymListToStr, PROG`
	`NFA`	`StrSet`		symmetric
`sing, SET`		strsOfValidPumpingDivision			`REL`
`SingArr, LEX`			`LP`		`SYM_REL`
`singCC, REG`			`PT`	symmetricClosure
size		`StrToSymList, PROG`			`REL`
	`PROG`	sub			`SYM_REL`
	`PT`		`DFA`	`SymRel`
	`REG`		`EFA`	`SymSet`
	`SET`		`FA`	`symToPP, LEX`
	`SYM`		`GRAM`	`symTopToSym, LEX`
`sizeSym, LEX`			`LIST_AUX`	`symToString, LEX`
`Snd, PROG`			`NFA`	`symToSymTop, LEX`
`SORT`			`RFA`	`SYSTEM`
`Sort`		subset		`System`
`sort, SORT`			`DFA`
`sorted, SORT`			`PROD_SET`
`sortUnions, REG`			`SET`
`split, REG`			`STR_SET`
splitAt			`SYM_REL`
	`LIST_AUX`		`SYM_SET`
	`LP`		`TRAN_REG_SET`
			`TRAN_SET`
			`VAR_SET`

T

`TAB`		`toReg, RFA`		`tran, TRAN`
`Tab`		`toRep, PROG`		`TRAN_REG`
`tab, TAB`		`toStr, PROG`		`tran_reg, TRAN_REG`
`Tilde, LEX`		toString		`TRAN_REG_SET`
`times, SET`			`DFA`	`TRAN_SET`
`times3, SET`			`EFA`	`TranReg`
`tl, SET`			`FA`	`TranRegSet`
`toClosed, PROG`			`GRAM`	`TranSet`
toConcr			`LP`	transitionFun
	`FA`		`NFA`		`DFA`
	`GRAM`		`PP`		`EFA`
	`LP`		`PROD_SET`		`FA`
	`PROG`		`PROG`		`NFA`
	`PT`		`PT`	transitionFunBackwards
	`REG`		`REG`		`DFA`
	`RFA`		`RFA`		`EFA`
`tok, LEX`			`STR`		`FA`
toList			`STR_SET`		`NFA`
	`SET`		`SYM`	transitions
	`TAB`		`SYM_REL`		`DFA`
`top, SYM`			`SYM_SET`		`EFA`
toPP			`TRAN_REG_SET`		`FA`
	`DFA`		`TRAN_SET`		`NFA`
	`EFA`		`VAR`		`RFA`
	`FA`		`VAR_SET`	transitive
	`GRAM`	toStrSet			`REL`
	`LP`		`GRAM`		`SYM_REL`
	`NFA`		`REG`	transitiveClosure
	`PROD_SET`	toStrSetOpt			`REL`
	`PROG`		`GRAM`		`SYM_REL`
	`PT`		`REG`	transitiveSymmetricClosure
	`REG`	total			`REL`
	`RFA`		`REL`		`SYM_REL`
	`STR`		`SYM_REL`	`True, PROG`
	`STR_SET`	`total_ordering, SORT`
	`SYM`	`toTop, SYM`
	`SYM_REL`	`TRAN`
	`SYM_SET`	`Tran`
	`TRAN_REG_SET`
	`TRAN_SET`
	`VAR`
	`VAR_SET`

U

`unexpectedTok, LEX`		`unionCC, REG`		`USE`
`Union, REG`		`unionsToList, REG`		`Use`
union		`Unknown, PROG`		`use, USE`
	`EFA`	update
	`FA`		`LIST_AUX`
	`GRAM`		`PROG`
	`PROD_SET`		`PT`
	`REG`		`REG`
	`SET`		`TAB`
	`STR_SET`	updateFunction
	`SYM_REL`		`REL`
	`SYM_SET`		`SYM_REL`
	`TRAN_REG_SET`
	`TRAN_SET`
	`VAR_SET`

V

valid		validPath		`var, VAR`
	`DFA`		`PROG`	`var, PROG`
	`EFA`		`PT`	`VAR_SET`
	`FA`		`REG`	`variables, GRAM`
	`GRAM`	`validPT, GRAM`		`VarSet`
	`NFA`	validPumpingDivision		`VERSION`
	`RFA`		`LP`	`Version`
validLeafPath			`PT`
	`PROG`	`Value, PROG`
	`PT`	`VAR`
	`REG`	`Var`
validLP		`Var, PROG`
	`DFA`
	`EFA`
	`FA`
	`NFA`
	`RFA`

W

weaklySimplified, REG

weaklySimplify, REG

Y

yield, PT

[ Top | Parent | Root | Contents ]