Index

'¯¯' -> Value, '¯¯'

'¯B' -> Value, '¯B'

'*' -> Number, '*'

'*' -> FD, '*'

'+' -> Number, '+'

'+' -> FD, '+'

'-' -> Number, '-'

'-' -> FD, '-'

'.' -> NoNumber, '.'

'/' -> Float,'/'

'>' -> Value, '>'

'>' -> FD, '>'

'>=' -> Value, '>='

'>=' -> FD, '>='

'>=B' -> Value, '>=B'

'>B' -> Value, '>B'

'<' -> Value, '<'

'<' -> FD, '<'

'<B' -> Value, '<B'

'=' -> Value, '='

'=<' -> Value, '=<'

'=<' -> FD, '=<'

'=<B' -> Value, '=<B'

'==' -> Value, '=='

'==B' -> Value, '==B'

'class' -> Inheritable, 'class'

'div' -> Int, 'div'

'div' -> FD, 'div'

'false' -> False

'mod' -> Int, 'mod'

'mod' -> FD, 'mod'

'not' -> Not

'true' -> True

'|' -> UrObject, '|'

' ' -> Number, ' '

* -> Number, '*'

* -> FD, '*'

+ -> Number, '+'

+ -> FD, '+'

- -> Number, '-'

- -> FD, '-'

. -> NoNumber, '.'

/ -> Float,'/'

:: -> FD, dom

::: -> FD, doms

> -> Value, '>'

> -> Value, '>B'

> -> FD, '>'

>= -> Value, '>='

>= -> Value, '>=B'

>= -> FD, '>='

< -> Value, '<'

< -> Value, '<B'

< -> FD, '<'

"class@ class -> `class`

"create@ create -> `create`

"div@ div -> Int, 'div'

"mod@ mod -> Int, 'mod'

"|@ -> UrObject,

forAllB

forAll

forSomeB

forSome

map

foldL

foldR

filter

filterB

forAllIndB

forAllInd

forSomeIndB

forSomeInd

mapInd

foldLInd

foldRInd

filterIndB

filterInd

depth

breadth

bound

iter

eager

lazy

bab

restart

setRepAll

getRep

setRepAction

setRepFinal

setRepKillAction

setRepDelay

setRepNum

setRepKillDelay

setRepDelayFun

setRepPriority

go

stop

kill

forAllIndB -> Array, forAllIndB

forAllInd -> Array, forAllInd

forSomeIndB -> Array, forSomeIndB

forSomeInd -> Array, forSomeInd

mapInd -> Array, mapInd

foldLInd -> Array, foldLInd

foldRInd -> Array, foldRInd

resize

put

init

get

put

dim

forAllB

forAll

forSomeB

forSome

map

foldL

foldR

forAllInd

forSomeIndB

forSomeIndB

forSomeInd

mapInd

foldLInd

foldRInd

forAllIndB -> Dictionary, forAllIndB

forAllInd -> Dictionary, forAllInd

forSomeIndB -> Dictionary, forSomeIndB

forSomeInd -> Dictionary, forSomeInd

mapInd -> Dictionary, mapInd

foldLInd -> Dictionary, foldLInd

foldRInd -> Dictionary, foldRInd

=¯ -> Value, '¯¯'

=¯ -> Value, '¯B'

=¯: -> FD, genNeq

=¯: -> FD, genNeqNL

=¯: -> FD, genNeqB

=¯: -> FD, genNeqNLB

= -> Value, '='

=: -> FD, genEq

=: -> FD, genEqNL

=: -> FD, genEqNLProp

=: -> FD, genEqB

=: -> FD, genEqNLB

=< -> FD, '=<'

=< -> Value, '=<'

=< -> Value, '=<B'

=<: -> FD, genLeq

=<: -> FD, genLeqNL

=<: -> FD, genLeqNLProp

=<: -> FD, genLeqB

=<: -> FD, genLeqNLB

== -> Value, '==B'

== -> Value, '=='

\:: -> FD, coDom

\::: -> FD, coDoms

`class`

`create`

`GetThreadPriority`

`ooCreate`

`SetThreadPriority`

Abs

abs -> Abs

abs -> FD, abs

Acos

acos -> Acos

action -> Search, action

Adjoin

adjoin -> Adjoin

adjoin -> Tuple, adjoin

AdjoinAt

adjoinAt -> AdjoinAt

adjoinAt -> Tuple, adjoinAt

AdjoinList

adjoinList -> AdjoinList

adjoinList -> Tuple, adjoinList

all -> Search, all

allDifferent -> FD, allDifferent

Append

append -> Append

Arity

arity -> Arity

arity -> Tuple, arity

arity -> ProcedureArity

Array

Array

foldL

foldLInd

foldR

foldRInd

forAll

forAllB

forAllInd

forAllIndB

forSome

forSomeB

forSomeInd

forSomeIndB

get

init

map

mapInd

put

size

Asin

asin -> Asin

Atan

atan -> Atan

atan2 -> Float, atan2

atLeast -> FD, atLeast

atMost -> FD, atMost

Atom

Atom

concat

is -> IsAtom

isB -> IsAtomB

length

toString -> AtomToString

AtomToString ,

Atom|)

automaticArray -> DataStructure, automaticArray

bab -> Search, best, bab

background -> Thread, background

best -> Search, best

Bool

Bool

'false' -> False

'not' -> Not

'true' -> True

is -> IsBool

isB -> IsBoolB

bool -> FD, bool

bools -> FD, bools

Bool|)

bound -> Search, one, bound

bound -> FiniteDomainBound

breadth -> Search, one, breadth

CallMethod

card -> FD, card

Ceil

ceil -> Ceil

Cell

Cell

exchange -> Exchange

is -> IsCell

isB -> IsCellB

new -> NewCell

Cell|)

changeSign -> VirtualString, changeSign

Char ,

Char

is -> IsChar

isAlNum

isAlNumB

isAlpha

isAlphaB

isB -> IsCharB

isCntrl

isCntrlB

isDigit

isDigitB

isGraph

isGraphB

isLower

isLowerB

isPrint

isPrintB

isPunct

isPunctB

isSpace

isSpaceB

isUpper

isUpperB

isXDigit

isXDigitB

toAtom

toLower

toUpper

type

Char|)

Chunk

Chunk

is -> IsChunk

isB -> IsChunkB

label

Chunk|)

Class

Class

is -> IsClass

isB -> IsClassB

list|(

list|)

parents

port -> Port

precedence

ur -> UrObject

Class|)

close -> UrObject, close

closed -> Object, closed

closedB -> Object, closedB

coDom -> FD, coDom

coDomB -> FD, coDomB

coDoms -> FD, coDoms

coDomsB -> FD, coDomsB

combinator -> SolveCombinator

con -> FD, con

concat -> Atom, concat

continue -> Thread, continue

Cos

cos -> Cos

count -> FD, count

DataStructure

array

foldL -> Array, foldL

foldR -> Array, foldR

forAll -> Array, forAll

forAllB -> Array, forAllB

forSome -> Array, forSome

forSomeB -> Array, forSomeB

get -> Array, get

init -> Array, init

map -> Array, map

put -> Array, put

size -> Array, size

array -> Array

automaticArray

dictionary

entries -> Dictionary, entries

foldL -> Dictionary, foldL

foldR -> Dictionary, foldR

forAll -> Dictionary, forAll

forAllB -> Dictionary, forAllB

forSome -> Dictionary, forSome

forSomeB -> Dictionary, forSomeB

get -> Dictionary, get

init -> Dictionary, init

map -> Dictionary, map

member -> Dictionary, member

memberB -> Dictionary, memberB

put -> Dictionary, put

remove -> Dictionary, remove

dictionary -> Dictionary

multiArray

resizableArray

default -> Thread, default

depth -> Search, one, depth

depth -> Search, depth

Det

det -> Det

DetB

detB -> DetB

Dictionary

Dictionary

entries

foldL

foldLInd

foldR

foldRInd

forAll

forAllB

forAllInd

forAllIndB

forSome

forSomeB

forSomeInd

forSomeIndB

get

init

map

mapInd

member

memberB

put

remove

dim -> DataStructure, multiArray, dim

dis -> FD, dis

dom -> FD, dom

domB -> FD, domB

doms -> FD, doms

domsB -> FD, domsB

drop -> List, drop

dropWhile -> Record, dropWhile

dropWhile -> Tuple, dropWhile

dropWhile -> List, dropWhile

dropWhileB -> Record, dropWhileB

dropWhileB -> Tuple, dropWhileB

dropWhileB -> List, dropWhileB

dropWhileInd -> Record, dropWhileInd

dropWhileInd -> Tuple, dropWhileInd

dropWhileInd -> List, dropWhileInd

dropWhileIndB -> Record, dropWhileIndB

dropWhileIndB -> Tuple, dropWhileIndB

dropWhileIndB -> List, dropWhileIndB

eager -> Search, all, eager

element -> FD, element

entries -> Dictionary, entries

enum -> FD, enum

enums -> FD, enums

enumSplit -> FD, enumSplit

enumSplits -> FD, enumSplits

equ -> FD, equ

Exchange

exchange -> Exchange

Exp

exp -> Exp

extend -> ExtendTuple

ExtendTuple

False

FD

FD

'*'

'+'

'-'

'>'

'>='

'<'

'=<'

'div'

'mod'

abs

allDifferent

atLeast

atMost

bool

bools

bound -> FiniteDomainBound

card

coDom

coDomB

coDoms

coDomsB

con

count

dis

dom

domB

doms

domsB

element

enum

enums

enumSplit

enumSplits

equ

fd -> FiniteDomain

genCard

genEq

genEqB

genEqNL

genEqNLB

genEqNLProp

genLeq

genLeqB

genLeqNL

genLeqNLB

genLeqNLProp

genNeq

genNeqB

genNeqNL

genNeqNLB

get -> GetFiniteDomain

getDomCompact

getMax

getMin

getNextTo

getSize

imp

is

max

min

ne -> FiniteDomainNE

neg

union

xor

fd -> FiniteDomain

FD|)

Filter

filter -> Record, filter

filter -> Tuple, filter

filter -> Class, list, filter

filter -> Filter

FilterB

filterB -> Record, filterB

filterB -> Tuple, filterB

filterB -> Class, list, filterB

filterB -> FilterB

filterInd -> Record, filterInd

filterInd -> Tuple, filterInd

filterInd -> Class, list, filterInd

filterInd -> List, filterInd

filterIndB -> Record, filterIndB

filterIndB -> Tuple, filterIndB

filterIndB -> Class, list, filterIndB

filterIndB -> List, filterIndB

FiniteDomain

FiniteDomainBound

FiniteDomainNE

Flatten

flatten -> Flatten

Float

Float

'/'

acos -> Acos

asin -> Asin

atan -> Atan

atan2

ceil -> Ceil

cos -> Cos

exp -> Exp

floor -> Floor

is -> IsFloat

isB -> IsFloatB

log -> Log

round

sin -> Sin

sqrt -> Sqrt

tan -> Tan

toInt -> FloatToInt

toString ,

FloatToInt

Float|)

Floor

floor -> Floor

folding ,

folding

left ,

right

FoldL

foldL -> Record, foldL

foldL -> Tuple, foldL

foldL -> Class, list, foldL

foldL -> FoldL

foldL -> Array, foldL

foldL -> DataStructure, multiArray, foldL

foldL -> Dictionary, foldL

foldLInd -> Record, foldLInd

foldLInd -> Tuple, foldLInd

foldLInd -> Class, list, foldLInd

foldLInd -> List, foldLInd

foldLInd -> Array, foldLInd

foldLInd -> DataStructure, multiArray, foldLInd

foldLInd -> Dictionary, foldLInd

FoldLTail

foldLTail -> FoldLTail

foldLTailInd -> List, foldLTailInd

FoldR

foldR -> Record, foldR

foldR -> Tuple, foldR

foldR -> Class, list, foldR

foldR -> FoldR

foldR -> Array, foldR

foldR -> DataStructure, multiArray, foldR

foldR -> Dictionary, foldR

foldRInd -> Record, foldRInd

foldRInd -> Tuple, foldRInd

foldRInd -> Class, list, foldRInd

foldRInd -> List, foldRInd

foldRInd -> Array, foldRInd

foldRInd -> DataStructure, multiArray, foldRInd

foldRInd -> Dictionary, foldRInd

FoldRTail

foldRTail -> FoldRTail

foldRTailInd -> List, foldRTailInd

for -> Loop, for

ForAll

forAll -> Record, forAll

forAll -> Tuple, forAll

forAll -> Class, list, forAll

forAll -> ForAll

forAll -> Array, forAll

forAll -> DataStructure, multiArray, forAll

forAll -> Dictionary, forAll

ForAllB

forAllB -> Record, forAllB

forAllB -> Tuple, forAllB

forAllB -> Class, list, forAllB

forAllB -> ForAllB

forAllB -> Array, forAllB

forAllB -> DataStructure, multiArray, forAllB

forAllB -> Dictionary, forAllB

forAllInd -> Record, forAllInd

forAllInd -> Tuple, forAllInd

forAllInd -> Class, list, forAllInd

forAllInd -> List, forAllInd

forAllInd -> Array, forAllInd

forAllInd -> DataStructure, multiArray, forAllInd

forAllInd -> Dictionary, forAllInd

forAllIndB -> Record, forAllIndB

forAllIndB -> Tuple, forAllIndB

forAllIndB -> Class, list, forAllIndB

forAllIndB -> List, forAllIndB

forAllIndB -> Array, forAllIndB

forAllIndB -> DataStructure, multiArray, forAllIndB

forAllIndB -> Dictionary, forAllIndB

ForAllTail

forAllTail -> ForAllTail

ForAllTailB

forAllTailB -> ForAllTailB

forAllTailInd -> List, forAllTailInd

forAllTailIndB -> List, forAllTailIndB

ForSome

forSome -> Record, forSome

forSome -> Tuple, forSome

forSome -> Class, list, forSomeB

forSome -> Class, list, forSome

forSome -> ForSome

forSome -> Array, forSome

forSome -> DataStructure, multiArray, forSome

forSome -> Dictionary, forSome

ForSomeB

forSomeB -> Record, forSomeB

forSomeB -> Tuple, forSomeB

forSomeB -> ForSomeB

forSomeB -> Array, forSomeB

forSomeB -> DataStructure, multiArray, forSomeB

forSomeB -> Dictionary, forSomeB

forSomeInd -> Record, forSomeInd

forSomeInd -> Tuple, forSomeInd

forSomeInd -> Class, list, forSomeInd

forSomeInd -> List, forSomeInd

forSomeInd -> Array, forSomeInd

forSomeInd -> DataStructure, multiArray, forSomeInd

forSomeInd -> Dictionary, forSomeInd

forSomeIndB -> Record, forSomeIndB

forSomeIndB -> Tuple, forSomeIndB

forSomeIndB -> Class, list, forSomeIndB

forSomeIndB -> List, forSomeIndB

forSomeIndB -> Array, forSomeIndB

forSomeIndB -> DataStructure, multiArray, forSomeIndB

forSomeIndB -> Dictionary, forSomeIndB

forThread -> Loop, forThread

genCard -> FD, genCard

genEq -> FD, genEq

genEqB -> FD, genEqB

genEqNL -> FD, genEqNL

genEqNLB -> FD, genEqNLB

genEqNLProp -> FD, genEqNLProp

genLeq -> FD, genLeq

genLeqB -> FD, genLeqB

genLeqNL -> FD, genLeqNL

genLeqNLB -> FD, genLeqNLB

genLeqNLProp -> FD, genLeqNLProp

genNeq -> FD, genNeq

genNeqB -> FD, genNeqB

genNeqNL -> FD, genNeqNL

genNeqNLB -> FD, genNeqNLB

get -> GetFiniteDomain

get -> Array, get

get -> DataStructure, multiArray, get

get -> Dictionary, get

getDomCompact -> FD, getDomCompact

GetFiniteDomain

getMax -> FD, getMax

getMin -> FD, getMin

getNextTo -> FD, getNextTo

getRep -> Time, repeat, getRep

getSize -> FD, getSize

getSlaves -> UrObject, getSlaves

go -> Time, repeat, go

HasSubtreeAt

hasSubtreeAt -> HasSubtreeAt

HasSubtreeAtB

hasSubtreeAtB -> HasSubtreeAtB

highInt -> Thread, highInt

imp -> FD, imp

Inherit

Inheritable

Inheritable

'class'

is -> IsInheritable

isB -> IsInheritableB

methodNames

new -> New

Inheritable|)id

init -> Port, init

init -> Port, init

init -> Port, init

init -> Search, init

init -> Array, init

init -> DataStructure, multiArray, init

init -> DataStructure, dictionary, init

Int

Int

'div'

'mod'

is -> IsInt

isB -> IsIntB

isEven -> IsEven

isEvenB -> IsEvenB

isNat -> IsNat

isNatB -> IsNatB

isOdd -> IsOdd

isOddB -> IsOddB

toFloat -> IntToFloat

toString ,

interrupt -> Thread, interrupt

IntToFloat

Int|)

is -> Det

is -> IsNoNumber

is -> IsRecord

is -> IsTuple

is -> IsLiteral

is -> IsAtom

is -> IsName

is -> IsChunk

is -> IsProcedure

is -> IsCell

is -> IsNumber

is -> IsInt

is -> IsFloat

is -> IsChar

is -> IsInheritable

is -> IsClass

is -> IsObject

is -> IsBool

is -> IsList

is -> IsString

is -> IsVirtualString

is -> FD, is

isAlNum -> Char, isAlNum

isAlNumB -> Char, isAlNumB

isAlpha -> Char, isAlpha

isAlphaB -> Char, isAlphaB

IsAtom

isAtom -> String, isAtom

IsAtomB

isAtomB -> String, isAtomB

isB -> DetB

isB -> IsNoNumberB

isB -> IsRecordB

isB -> IsTupleB

isB -> IsLiteralB

isB -> IsAtomB

isB -> IsNameB

isB -> IsChunkB

isB -> IsProcedureB

isB -> IsCellB

isB -> IsNumberB

isB -> IsIntB

isB -> IsFloatB

isB -> IsCharB

isB -> IsInheritableB

isB -> IsClassB

isB -> IsObjectB

isB -> IsBoolB

isB -> IsListB

isB -> IsStringB

isB -> IsVirtualStringB

IsBool

IsBoolB

IsCell

IsCellB

IsChar

IsCharB

IsChunk

IsChunkB

IsClass

IsClassB

isCntrl -> Char, isCntrl

isCntrlB -> Char, isCntrlB

isDigit -> Char, isDigit

isDigitB -> Char, isDigitB

IsEven

isEven -> IsEven

IsEvenB

isEvenB -> IsEvenB

IsFloat

isFloat -> String, isFloat

IsFloatB

isFloatB -> String, isFloatB

isGraph -> Char, isGraph

isGraphB -> Char, isGraphB

IsInheritable

IsInheritableB

IsInt

isInt -> String, isInt

IsIntB

isIntB -> String, isIntB

IsList

IsListB

IsLiteral

IsLiteralB

isLower -> Char, isLower

isLowerB -> Char, isLowerB

IsName

IsNameB

IsNat

isNat -> IsNat

IsNatB

isNatB -> IsNatB

IsNoNumber

IsNoNumberB

IsNumber

IsNumberB

IsObject

IsObjectB

IsOdd

isOdd -> IsOdd

IsOddB

isOddB -> IsOddB

isPrint -> Char, isPrint

isPrintB -> Char, isPrintB

IsProcedure

IsProcedureB

isPunct -> Char, isPunct

isPunctB -> Char, isPunctB

IsRecord

IsRecordB

isSpace -> Char, isSpace

isSpaceB -> Char, isSpaceB

IsString

IsStringB

IsTuple

IsTupleB

isUpper -> Char, isUpper

isUpperB -> Char, isUpperB

IsValue -> Det

IsValueB -> DetB

IsVirtualString

IsVirtualStringB

isXDigit -> Char, isXDigit

isXDigitB -> Char, isXDigitB

iter -> Search, one, iter

kill -> Time, repeat, kill

Label

label -> Label

label -> Chunk, label

last -> List, last

lazy -> Search, all, lazy

Length

length -> Atom, length

length -> Length

length -> VirtualString, length

Link

link -> Link

List

List

append -> Append

drop

dropWhile

dropWhileB

dropWhileInd

dropWhileIndB

filter -> Filter

filterB -> FilterB

filterInd

filterIndB

flatten -> Flatten

foldL -> FoldL

foldLInd

foldLTail -> FoldLTail

foldLTailInd

foldR -> FoldR

foldRInd

foldRTail -> FoldRTail

foldRTailInd

forAll -> ForAll

forAllB -> ForAllB

forAllInd

forAllIndB

forAllTail -> ForAllTail

forAllTailB -> ForAllTailB

forAllTailInd

forAllTailIndB

forSome -> ForSome

forSomeB -> ForSomeB

forSomeInd

forSomeIndB

is -> IsList

isB -> IsListB

last

length -> Length

list -> List

map -> Map

mapInd

member -> Member

memberB -> MemberB

merge -> Merge

mergeB -> MergeB

nth -> Nth

number

partition

partitionB

partitionInd

partitionIndB

reverse -> Reverse

sort -> Sort

sortB -> SortB

sub

subB

subtract

take

takeDrop

takeDropWhile

takeDropWhileB

takeDropWhileInd

takeDropWhileIndB

takeWhile

takeWhileB

takeWhileInd

takeWhileIndB

toRecord

toTuple

withTail

zip

list -> Class, list

list -> List

List|(

List|)

Literal

Literal

is -> IsLiteral

isB -> IsLiteralB

Literal|)

Log

log -> Log

Loop

Loop

for

forThread

multiFor

multiForThread

repeatUntil

repeatUntilB

whileDo

whileDoB

Loop|)

lowInt -> Thread, lowInt

Map

map -> Record, map

map -> Tuple, map

map -> Class, list, map

map -> Map

map -> Array, map

map -> DataStructure, multiArray, map

map -> Dictionary, map

mapInd -> Record, mapInd

mapInd -> Tuple, mapInd

mapInd -> Class, list, mapInd

mapInd -> List, mapInd

mapInd -> Array, mapInd

mapInd -> DataStructure, multiArray, mapInd

mapInd -> Dictionary, mapInd

Max

max -> Max

max -> FD, max

Member

member -> Member

member -> Dictionary, memberB

member -> Dictionary, member

MemberB

memberB -> MemberB

Merge

merge -> Merge

MergeB

mergeB -> MergeB

methodNames -> Inheritable, methodNames

methods

higher-order

middleInt -> Thread, middleInt

Min

min -> Min

min -> FD, min

multiArray -> DataStructure, multiArray

multiFor -> Loop, multiFor

multiForThread -> Loop, multiForThread

Name

Name

is -> IsName

isB -> IsNameB

new -> NewName

Name|)

ne -> FiniteDomainNE

neg -> FD, neg

New ,

new -> New

new -> NewName

new -> NewCell

NewCell

NewName

next -> Search, next

nil -> UrObject, nil

NoNumber

NoNumber

'.'

hasSubtreeAtB -> HasSubtreeAtB

is -> IsNoNumber

isB -> IsNoNumberB

label -> Label

subtree -> Subtree

width -> Width

NoNumber|)

Not

Nth

nth -> Nth

Number

Number

'*'

'+'

'-'

' '

abs -> Abs

is -> IsNumber

isB -> IsNumberB

pow -> Pow

number -> List, number

Number|)

Object

Object

callMethod -> CallMethod

closed

closedB

is -> IsObject

isB -> IsObjectB

Object|)

one -> Search, one

otherwise -> UrObject, otherwise

parents -> Class, parents

partition -> Record, partition

partition -> Tuple, partition

partition -> List, partition

partitionB -> Record, partitionB

partitionB -> Tuple, partitionB

partitionB -> List, partitionB

partitionInd -> Record, partitionInd

partitionInd -> Tuple, partitionInd

partitionInd -> List, partitionInd

partitionIndB -> Record, partitionIndB

partitionIndB -> Tuple, partitionIndB

partitionIndB -> List, partitionIndB

Port

Port

init , ,

Pow

pow -> Pow

precedence -> Class, precedence

preempt -> Thread, preempt

prev -> Search, prev

printName -> Procedure, printName

printName -> Procedure, printName

Procedure

Procedure

arity -> ProcedureArity

is -> IsProcedure

isB -> IsProcedureB

link -> Link

procedure

predefined

Procedure

printName ,

ProcedureArity

Procedure|)

put -> Array, put

put -> DataStructure, resizableArray, resize

put -> DataStructure, automaticArray, put

put -> DataStructure, multiArray, put

put -> Dictionary, put

query -> Search, query

Record ,

Record

adjoin -> Adjoin

adjoinAt -> AdjoinAt

adjoinList -> AdjoinList

arity -> Arity

dropWhile

dropWhileB

dropWhileInd

dropWhileIndB

filter

filterB

filterInd

filterIndB

foldL

foldLInd

foldR

foldRInd

forAll

forAllB

forAllInd

forAllIndB

forSome

forSomeB

forSomeInd

forSomeIndB

is -> IsRecord

isB -> IsRecordB

map

mapInd

partition

partitionB

partitionInd

partitionIndB

record -> Record

subtract

takeDropWhile

takeDropWhileB

takeDropWhileInd

takeDropWhileIndB

takeWhile

takeWhileB

takeWhileInd

takeWhileIndB

toList

toListInd

zip

record -> Record

Record|)

remove -> Dictionary, remove

repeat -> Time, repeat

repeatUntil -> Loop, repeatUntil

repeatUntilB -> Loop, repeatUntilB

resizableArray -> DataStructure, resizableArray

restart -> Search, best, restart

Reverse

reverse -> Reverse

round -> Float, round

Search ,

Search

action

all

all|)

best

best|)

combinator -> SolveCombinator

depth

init

next

one

one|)

prev

query

stop

strip

Search|) ,

sendSync -> UrObject, sendSync

setBackgroundPri -> Thread, setBackgroundPri

setDefaultPri -> Thread, setDefaultPri

setHighIntPri -> Thread, setHighIntPri

setLowIntPri -> Thread, setLowIntPri

setMiddleIntPri -> Thread, setMiddleIntPri

setRepAction -> Time, repeat, setRepAction

setRepAll -> Time, repeat, setRepAll

setRepDelay -> Time, repeat, setRepDelay

setRepDelayFun -> Time, repeat, setRepDelayFun

setRepFinal -> Time, repeat, setRepFinal

setRepKillAction -> Time, repeat, setRepKillAction

setRepKillDelay -> Time, repeat, setRepKillDelay

setRepNum -> Time, repeat, setRepNum

setRepPriority -> Time, repeat, setRepPriority

Sin

sin -> Sin

size -> Array, size

slave -> UrObject, slave

Sleep

sleep -> Sleep

SolveCombinator

sort -> Sort

SortB ,

sortB -> SortB

Sqrt

sqrt -> Sqrt

stop -> Search, stop

stop -> Time, repeat, stop

string ,

String

is -> IsString

isAtom

isAtomB

isB -> IsStringB

isFloat

isFloatB

isInt

isIntB

toAtom -> StringToAtom

toFloat

toInt

strings

virtual

StringToAtom ,

String|)

strip -> Search, strip

sub -> List, sub

subB -> List, subB

subtract -> Record, subtract

subtract -> List, subtract

Subtree ,

subtree -> Subtree

sync -> UrObject, sync

take -> List, take

takeDrop -> List, takeDrop

takeDropWhile -> Record, takeDropWhile

takeDropWhile -> Tuple, takeDropWhile

takeDropWhile -> List, takeDropWhile

takeDropWhileB -> Record, takeDropWhileB

takeDropWhileB -> Tuple, takeDropWhileB

takeDropWhileB -> List, takeDropWhileB

takeDropWhileInd -> Record, takeDropWhileInd

takeDropWhileInd -> Tuple, takeDropWhileInd

takeDropWhileInd -> List, takeDropWhileInd

takeDropWhileInd -> List, takeDropWhileInd

takeDropWhileIndB -> Record, takeDropWhileIndB

takeDropWhileIndB -> Tuple, takeDropWhileIndB

takeWhile -> Record, takeWhile

takeWhile -> Tuple, takeWhile

takeWhile -> List, takeWhile

takeWhileB -> Record, takeWhileB

takeWhileB -> Tuple, takeWhileB

takeWhileB -> List, takeWhileB

takeWhileInd -> Record, takeWhileInd

takeWhileInd -> Tuple, takeWhileInd

takeWhileInd -> List, takeWhileInd

takeWhileIndB -> Record, takeWhileIndB

takeWhileIndB -> Tuple, takeWhileIndB

takeWhileIndB -> List, takeWhileIndB

Tan

tan -> Tan

Thread

Thread

background

continue

default

getPriority -> `GetThreadPriority`

highInt

interrupt

lowInt

middleInt

preempt

setBackgroundPri

setDefaultPri

setHighIntPri

setLowIntPri

setMiddleIntPri

setPriority -> `SetThreadPriority`

Thread|)

Time ,

Time

repeat

sleep -> Sleep

time -> Time

time -> Time

Time|)

toAtom -> Char, toAtom

toAtom -> StringToAtom

toFloat -> IntToFloat

toFloat -> String, toFloat

toInt -> FloatToInt

toInt -> String, toInt

toList -> Record, toList

toList -> Tuple, toList

toListInd -> Record, toListInd

toListInd -> Tuple, toListInd

toLower -> Char, toLower

toRecord -> List, toRecord

toString -> AtomToString

toString -> Int, toString

toString -> Float, toString

toString -> VirtualString, toString

toTuple -> List, toTuple

toUpper -> Char, toUpper

True

Tuple ,

Tuple

adjoin

adjoinAt

adjoinList

arity

dropWhile

dropWhileB

dropWhileInd

dropWhileIndB

extend -> ExtendTuple

filter

filterB

filterInd

filterIndB

foldL

foldLInd

foldR

foldRInd

forAll

forAllB

forAllInd

forAllIndB

forSome

forSomeB

forSomeInd

forSomeIndB

is -> IsTuple

isB -> IsTupleB

map

mapInd

partition

partitionB

partitionInd

partitionIndB

takeDropWhile

takeDropWhileB

takeDropWhileInd

takeDropWhileIndB

takeWhile

takeWhileB

takeWhileInd

takeWhileIndB

toList

toListInd

tuple -> Tuple

zip

tuple -> Tuple

Tuple|)

type -> Value, type

type -> Char, type

union -> FD, union

unSlave -> UrObject, unSlave

UrObject

UrObject

'|'

close

getSlaves

nil

otherwise

sendSync

slave

sync

unSlave

Value

Value

'¯¯'

'¯B'

'>'

'>='

'>=B'

'>B'

'<'

'<B'

'='

'=<'

'=<B'

'=='

'==B'

det -> Det

detB -> DetB

is -> Det

isB -> DetB

max -> Max

min -> Min

type

Value|)

VirtualString ,

VirtualString

changeSign

is -> IsVirtualString

isB -> IsVirtualStringB

length

toString

VirtualString|)

whileDo -> Loop, whileDo

whileDoB -> Loop, whileDoB

Width

width -> Width

withTail -> List, withTail

xor -> FD, xor

zip -> Record, zip

zip -> Tuple, zip

zip -> List, zip

-> Number, ' '