next node: Function Index By Codomain,
prev node: [ a ] to [ d ],
up to node: Function Index By Codomain


Function Index By Codomain [ e ] to [ v ]

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

e

env fun method -> method -> env ** general -> result
env recursion method -> env ** general -> result

g

general fun method -> method -> env ** general -> result
general fun method -> method -> general -> result
general recursion method -> env ** general -> result
general recursion method -> general -> result

i

instances :: coreReflection ** instances -> instances
instances <> instances

k

kind kind name -> kind
kind sort kind
kind value type -> kind

l

lazy eager alpha -> lazy
lazy lazy (() -> alpha) -> lazy

m

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[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] default method[sto, 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] default method[value, com[void], output]
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] default method[value, denotation]
method[value, denotation] seq method[value, denotation] -> method[value, denotation]
method[value, denotation] set method[value, denotation] -> method[value, denotation]

n

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

o

object lookup map[origin, <, struct] ** name -> object
option[ident] findSort denotation ** struct -> option[ident]
option[interOpal] ok? denotation -> option[interOpal] -> com[interOpal]
option[origin] findStruct denotation ** map[origin, <, struct] -> option[origin]
output nat method[value, com[void], output] -> output ** nat -> com[void]
output print method[value, com[void], output] -> output ** alpha -> com[void]

r

result fun method -> method -> env ** general -> result
result fun method -> method -> general -> result
result recursion method -> env ** general -> result
result recursion method -> general -> result

s

seq[denotation] getInterOpalFileNames denotation -> seq[denotation]
seq[name] formalParams struct -> seq[name]
seq[name] instance struct -> seq[name]
seq[object] findObjectsByName denotation ** interOpal -> seq[object]
seq[type] components variant -> seq[type]
seq[type] factors type -> seq[type]
seq[value] untuple value -> seq[value]
seq[variant] variants sort -> seq[variant]
seq[variant] variants type -> seq[variant]
sort reflectSort sort
sort sort name -> sort
sort sort type -> sort
sto < value ** value -> sto
sto = value ** value -> sto
struct getMainStruct interOpal -> struct
struct struct denotation ** seq[name] -> struct
struct struct name -> struct

t

type basic sort -> type
type codomain type -> type
type domain type -> type
type function type ** type -> type
type product seq[type] -> type
type type kind -> type

v

value apply value ** value -> value
value bind name -> value
value constructor variant -> value -> value
value deconstructor variant -> value -> value
value discriminator variant -> value -> bool
value reflect alpha -> value
value tuple seq[value] -> value
value x sto -> value
value y sto -> value
variant variant name ** seq[type] ** (value -> value) ** (value -> bool) ** (value -> value) -> variant


next node: Function Index By Codomain,
prev node: [ a ] to [ d ],
up to node: Function Index By Codomain