next node: [ n ] to [ t ],
prev node: Function Index By Domain,
up to node: Function Index By Domain


Function Index By Domain [ a ] to [ m ]

[ a ] [ b ] [ c ] [ d ] [ e ] [ f ] [ g ] [ i ] [ k ] [ l ] [ m ] [ n ] [ o ] [ p ] [ r ] [ s ] [ t ] [ v ]

a

alpha < alpha ** alpha -> bool
alpha = alpha ** alpha -> bool
alpha eager alpha -> lazy
alpha lazy (() -> alpha) -> lazy
alpha print alpha -> denotation
alpha print output ** alpha -> com[void]
alpha reflect alpha -> value

b

bool :: (general -> bool) ** (method[general, result, env] -> env ** general -> result) ** method[general, result, env] -> method[general, result, env]
bool :: (general -> bool) ** (method[general, result] -> general -> result) ** method[general, result] -> method[general, result]
bool dynamic? struct ** name ** (pragma -> bool) -> bool
bool dynamic? struct ** nat ** (pragma -> bool) -> bool
bool variant name ** seq[type] ** (value -> value) ** (value -> bool) ** (value -> value) -> variant

c

cache ! cache ** dom -> codom
codom cache (dom -> codom) ** map[dom, <, codom] -> cache
codom cache (dom -> codom) -> cache
coreReflection :: coreReflection ** instances -> instances
coreReflection basic coreReflection -> coreType
coreType :: coreType ** coreType -> coreType
coreType function coreType ** coreType -> coreType
coreType value denotation ** denotation ** instances ** coreType -> coreReflection

d

denotation = object ** denotation ** kind -> bool
denotation baseName denotation -> denotation
denotation findObjectsByName denotation ** interOpal -> seq[object]
denotation findSort denotation ** struct -> option[ident]
denotation findStruct denotation ** map[origin, <, struct] -> option[origin]
denotation getInterOpalFileNames denotation -> seq[denotation]
denotation loadInterOpal denotation -> com[option[interOpal]]
denotation name denotation ** kind ** struct -> name
denotation ok? denotation -> option[interOpal] -> com[interOpal]
denotation sort denotation ** denotation ** instances -> coreReflection
denotation struct denotation ** seq[name] -> struct
denotation value denotation ** denotation ** instances ** coreType -> coreReflection
dom ! cache ** dom -> codom
dom < dom ** dom -> bool
dom cache (dom -> codom) ** map[dom, <, codom] -> cache
dom cache (dom -> codom) -> cache

e

env :: (general -> bool) ** (method[general, result, env] -> env ** general -> result) ** method[general, result, env] -> method[general, result, env]
env :: (method[general, result, env] -> env ** special -> result) ** method[general, result, env] -> method[general, result, env]
env method (method -> env ** general -> result) -> method

f

fct = fct ** fct -> bool

g

general :: (general -> bool) ** (method[general, result, env] -> env ** general -> result) ** method[general, result, env] -> method[general, result, env]
general :: (general -> bool) ** (method[general, result] -> general -> result) ** method[general, result] -> method[general, result]
general method (method -> env ** general -> result) -> method
general method (method -> general -> result) -> method

i

ident = ident ** ident -> bool
inst = inst ** inst -> bool
instances :: coreReflection ** instances -> instances
instances sort denotation ** denotation ** instances -> coreReflection
instances value denotation ** denotation ** instances ** coreType -> coreReflection
interOpal findObjectsByName denotation ** interOpal -> seq[object]
interOpal getMainStruct interOpal -> struct
interOpal getModuleNameAsDeno interOpal ** name -> denotation
interOpal getNameAsDeno interOpal ** name -> denotation

k

kind < kind ** kind -> bool
kind = kind ** kind -> bool : [1], [2]
kind = object ** denotation ** kind -> bool
kind ` kind -> denotation
kind name denotation ** kind ** struct -> name
kind sort? kind -> bool
kind type kind -> type
kind value? kind -> bool

l

lazy code lazy -> () -> alpha
lazy eval lazy -> alpha

m

map[dom, <, codom] cache (dom -> codom) ** map[dom, <, codom] -> cache
map[origin, <, struct] findStruct denotation ** map[origin, <, struct] -> option[origin]
map[origin, <, struct] lookup map[origin, <, struct] ** name -> object
map[origin, <, struct] newOriginNo map[origin, <, struct] -> nat
method fun method -> method -> env ** general -> result
method fun method -> method -> general -> result
method method (method -> env ** general -> result) -> method
method method (method -> general -> result) -> method
method method? method -> bool : [1], [2]
method recursion method -> env ** general -> result
method recursion method -> general -> result
method[general, result, env] :: (general -> bool) ** (method[general, result, env] -> env ** general -> result) ** method[general, result, env] -> method[general, result, env]
method[general, result, env] :: (method[general, result, env] -> env ** special -> result) ** method[general, result, env] -> method[general, result, env]
method[general, result, env] :: (method[general, result, env] -> method[general, result, env]) ** method[general, result, env] -> method[general, result, env]
method[general, result] :: (general -> bool) ** (method[general, result] -> general -> result) ** method[general, result] -> method[general, result]
method[general, result] :: (method[general, result] -> method[general, result]) ** method[general, result] -> method[general, result]
method[general, result] :: (method[general, result] -> special -> result) ** method[general, result] -> method[general, result]
method[sto, bool] < method[sto, bool] -> alpha ** alpha -> bool
method[sto, bool] = method[sto, bool] -> alpha ** alpha -> bool
method[sto, bool] map method[sto, bool] -> method[sto, bool]
method[sto, bool] seq method[sto, bool] -> method[sto, bool]
method[sto, bool] set method[sto, bool] -> method[sto, bool]
method[value, com[void], output] nat method[value, com[void], output] -> output ** nat -> com[void]
method[value, com[void], output] print method[value, com[void], output] -> output ** alpha -> com[void]
method[value, com[void], output] seq method[value, com[void], output] -> method[value, com[void], output]
method[value, com[void], output] set method[value, com[void], output] -> method[value, com[void], output]
method[value, denotation] nat method[value, denotation] -> nat -> denotation
method[value, denotation] print method[value, denotation] -> alpha -> denotation
method[value, denotation] seq method[value, denotation] -> method[value, denotation]
method[value, denotation] set method[value, denotation] -> method[value, denotation]


next node: [ n ] to [ t ],
prev node: Function Index By Domain,
up to node: Function Index By Domain