next node: [ v ],
prev node: [ a ] to [ m ],
up to node: Function Index By Domain


Function Index By Domain [ n ] to [ t ]

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

n

name < name ** name -> bool
name = name ** name -> bool : [1], [2]
name ` name -> denotation
name bind name -> value
name dynamic? struct ** name ** (pragma -> bool) -> bool
name dynamic? struct ** name -> bool
name getModuleNameAsDeno interOpal ** name -> denotation
name getNameAsDeno interOpal ** name -> denotation
name identifier name -> denotation
name kind name -> kind
name lookup map[origin, <, struct] ** name -> object
name name? name -> bool
name sort name -> sort
name struct name -> struct
name variant name ** seq[type] ** (value -> value) ** (value -> bool) ** (value -> value) -> variant
nat dynamic? struct ** nat ** (pragma -> bool) -> bool
nat dynamic? struct ** nat -> bool

o

object = object ** denotation ** kind -> bool
origin = origin ** origin -> bool
output print output ** alpha -> com[void]
output printDefault output ** value -> com[void]

p

pragma dynamic? struct ** name ** (pragma -> bool) -> bool
pragma dynamic? struct ** nat ** (pragma -> bool) -> bool

r

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

s

seq[name] struct denotation ** seq[name] -> struct
seq[type] product seq[type] -> type
seq[type] variant name ** seq[type] ** (value -> value) ** (value -> bool) ** (value -> value) -> variant
seq[value] tuple seq[value] -> value
sort < sort ** sort -> bool
sort = sort ** sort -> bool
sort ` sort -> denotation
sort basic sort -> type
sort freeType? sort -> bool
sort name sort -> name
sort sort? sort -> bool
sort variants sort -> seq[variant]
special :: (method[general, result, env] -> env ** special -> result) ** method[general, result, env] -> method[general, result, env]
special :: (method[general, result] -> special -> result) ** method[general, result] -> method[general, result]
sto <? sto -> bool
sto =? sto -> bool
sto nat sto -> bool
sto x sto -> value
sto y sto -> value
struct < struct ** struct -> bool
struct = struct ** struct -> bool
struct ` struct -> denotation
struct dynamic? struct ** name ** (pragma -> bool) -> bool
struct dynamic? struct ** name -> bool
struct dynamic? struct ** nat ** (pragma -> bool) -> bool
struct dynamic? struct ** nat -> bool
struct findSort denotation ** struct -> option[ident]
struct formalParams struct -> seq[name]
struct identifier struct -> denotation
struct instance struct -> seq[name]
struct name denotation ** kind ** struct -> name
struct newIdentNo struct -> nat
struct newInstNo struct -> nat
struct struct? struct -> bool

t

type < type ** type -> bool
type = type ** type -> bool
type ` type -> denotation
type basic? type -> bool
type codomain type -> type
type domain type -> type
type factors type -> seq[type]
type freeType? type -> bool
type function type ** type -> type
type function? type -> bool
type product? type -> bool
type sort type -> sort
type value type -> kind
type variants type -> seq[variant]


next node: [ v ],
prev node: [ a ] to [ m ],
up to node: Function Index By Domain