next node: [ g ] to [ v ],
prev node: Function Index,
up to node: Function Index

Function Index [ ! ] to [ f ]

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

!

! cache ** dom -> codom

:

:: (general -> bool) ** (method[general, result, env] -> env ** general -> result) ** method[general, result, env] -> method[general, result, env]
:: (general -> bool) ** (method[general, result] -> general -> result) ** method[general, result] -> method[general, result]
:: (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] -> method[general, result]) ** method[general, result] -> method[general, result]
:: (method[general, result] -> special -> result) ** method[general, result] -> method[general, result]
:: coreReflection ** instances -> instances
:: coreType ** coreType -> coreType

<

< alpha ** alpha -> bool
< dom ** dom -> bool
< kind ** kind -> bool
< method[sto, bool] -> alpha ** alpha -> bool
< name ** name -> bool
< sort ** sort -> bool
< struct ** struct -> bool
< type ** type -> bool
< value ** value -> sto
<> coreType
<> instances
<? sto -> bool

=

= alpha ** alpha -> bool
= fct ** fct -> bool
= ident ** ident -> bool
= inst ** inst -> bool
= kind ** kind -> bool : [1], [2]
= method[sto, bool] -> alpha ** alpha -> bool
= name ** name -> bool : [1], [2]
= object ** denotation ** kind -> bool
= origin ** origin -> bool
= sort ** sort -> bool
= struct ** struct -> bool
= type ** type -> bool
= value ** value -> sto
=? sto -> bool

`

` kind -> denotation
` name -> denotation
` sort -> denotation
` struct -> denotation
` type -> denotation

a

applicable? value ** value -> bool
apply value ** value -> value

b

baseName denotation -> denotation
basic coreReflection -> coreType
basic sort -> type
basic? type -> bool
bind name -> value

c

cache (dom -> codom) ** map[dom, <, codom] -> cache
cache (dom -> codom) -> cache
code lazy -> () -> alpha
codomain type -> type
components variant -> seq[type]
constructor variant -> value -> value
constructorName variant -> name
content value -> alpha

d

deconstructor variant -> value -> value
default method[sto, bool]
default method[value, com[void], output]
default method[value, denotation]
discriminator variant -> value -> bool
domain type -> type
dynamic? struct ** name ** (pragma -> bool) -> bool
dynamic? struct ** name -> bool
dynamic? struct ** nat ** (pragma -> bool) -> bool
dynamic? struct ** nat -> bool

e

eager alpha -> lazy
eval lazy -> alpha

f

factors type -> seq[type]
findObjectsByName denotation ** interOpal -> seq[object]
findSort denotation ** struct -> option[ident]
findStruct denotation ** map[origin, <, struct] -> option[origin]
formalParams struct -> seq[name]
freeType? sort -> bool
freeType? type -> bool
fun method -> method -> env ** general -> result
fun method -> method -> general -> result
function coreType ** coreType -> coreType
function type ** type -> type
function? type -> bool

next node: [ g ] to [ v ],
prev node: Function Index,
up to node: Function Index