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

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

E

`EFA`		emptyStr		`equalTok, LEX`
`EFA`			`DFA`	`equivalent, DFA`
`efa, EFA`			`EFA`	`Error, MESSAGES`
`eliminateEmptyAndUnitProductions, GRAM`			`FA`	`Error, PROG`
`eliminateEmptyProductions, GRAM`			`GRAM`	`error, LEX`
`eliminateState, RFA`			`NFA`	`errorNotEOFTerminated, LEX`
empty			`REG`	`errorPP, MESSAGES`
	`PP`	`endState, LP`		`errorString, MESSAGES`
	`SET`	`EOF, LEX`		`evaluate, PROG`
	`TAB`	`Equal, DFA`		`exists, SET`
emptyClose		equal		`expectedDigit, LEX`
	`EFA`		`DFA`	`expectedLetter, LEX`
	`FA`		`EFA`	`expectedLetterOrDigit, LEX`
emptyCloseBackwards			`FA`	`expectedTok, LEX`
	`EFA`		`GRAM`
	`FA`		`LP`
`EmptySet, REG`			`NFA`
emptySet			`PROD`
	`DFA`		`PROD_SET`
	`EFA`		`PROG`
	`FA`		`PT`
	`GRAM`		`REG`
	`NFA`		`RFA`
	`REG`		`SET`
`EmptyStr, REG`			`SORT`
			`STR`
			`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`	`getTrackExceptions, PARAMS`
`generated, GRAM`			`PROD_SET`	`getVersion, VERSION`
`generatedFromVariable, GRAM`			`REG`	`getWorkingDirectory, PARAMS`
genInter			`SET`	`globallySimplified, REG`
	`DFA`		`STR_SET`	`globallySimplify, REG`
	`EFA`		`SYM_REL`	`globallySimplifyTrace, REG`
	`NFA`		`SYM_SET`	`GRAM`
	`PROD_SET`		`TRAN_REG_SET`	`Gram`
	`SET`		`TRAN_SET`	`gram, GRAM`
	`STR_SET`		`VAR_SET`
	`SYM_REL`	`getCompilationManagerVerbosity, PARAMS`
	`SYM_SET`	`getPrintingDataStructureDepth, PARAMS`
	`TRAN_REG_SET`
	`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`	`letRec, PROG`	`locallySimplified, REG`
`Lam, PROG`	`LetSimp, PROG`	`locallySimplify, REG`
`lam, PROG`	`letSimp, PROG`	`locallySimplifyTrace, REG`
`last, STR`	`LEX`	`localSimplificationRelations, REG`
`leaf, PT`	`Lex`	`lookup, TAB`
`length, LP`	`lexFile, LEX`	`LP`
`less, SORT`	`lexString, LEX`	`LP`
`lessEqual, SORT`	`LIST_AUX`	`lp, LP`
`LetRec, PROG`	`ListAux`

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

Q

quiet, MESSAGES

quote, PP

R

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

S

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

T

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