next node: Function Index,
prev node: [ ! ] to [ f ],
up to node: Function Index


Function Index [ g ] to [ v ]

[ ! ] [ : ] [ < ] [ = ] [ ` ] [ a ] [ b ] [ c ] [ d ] [ e ] [ f ] [ g ] [ i ] [ k ] [ l ] [ m ] [ n ] [ o ] [ p ] [ r ] [ s ] [ t ] [ u ] [ v ] [ x ] [ y ]

g

getInterOpalFileNames denotation -> seq[denotation]
getMainStruct interOpal -> struct
getModuleNameAsDeno interOpal ** name -> denotation
getNameAsDeno interOpal ** name -> denotation

i

identifier name -> denotation
identifier struct -> denotation
instance struct -> seq[name]
interOpalRepository cache[denotation, <, option[interOpal]]

k

kind name -> kind

l

lazy (() -> alpha) -> lazy
loadInterOpal denotation -> com[option[interOpal]]
lookup map[origin, <, struct] ** name -> object

m

map method[sto, bool] -> method[sto, bool]
method (method -> env ** general -> result) -> method
method (method -> general -> result) -> method
method? method -> bool : [1], [2]

n

name denotation ** kind ** struct -> name
name sort -> name
name? name -> bool
nat method[value, com[void], output] -> output ** nat -> com[void]
nat method[value, denotation] -> nat -> denotation
nat sto -> bool
newIdentNo struct -> nat
newInstNo struct -> nat
newOriginNo map[origin, <, struct] -> nat

o

ok? denotation -> option[interOpal] -> com[interOpal]

p

print alpha -> denotation
print method[value, com[void], output] -> output ** alpha -> com[void]
print method[value, denotation] -> alpha -> denotation
print output ** alpha -> com[void]
printDefault output ** value -> com[void]
product seq[type] -> type
product? type -> bool

r

recursion method -> env ** general -> result
recursion method -> general -> result
reflect alpha -> value
reflects? value -> bool
reflectSort sort

s

seq method[sto, bool] -> method[sto, bool]
seq method[value, com[void], output] -> method[value, com[void], output]
seq method[value, denotation] -> method[value, denotation]
set method[sto, bool] -> method[sto, bool]
set method[value, com[void], output] -> method[value, com[void], output]
set method[value, denotation] -> method[value, denotation]
sort denotation ** denotation ** instances -> coreReflection
sort kind
sort name -> sort
sort type -> sort
sort? kind -> bool
sort? sort -> bool
struct denotation ** seq[name] -> struct
struct name -> struct
struct? struct -> bool

t

tuple seq[value] -> value
type kind -> type

u

untuple value -> seq[value]

v

value denotation ** denotation ** instances ** coreType -> coreReflection
value type -> kind
value? kind -> bool
variant name ** seq[type] ** (value -> value) ** (value -> bool) ** (value -> value) -> variant
variant? variant -> bool
variants sort -> seq[variant]
variants type -> seq[variant]

x

x sto -> value

y

y sto -> value


next node: Function Index,
prev node: [ ! ] to [ f ],
up to node: Function Index