next node: [ de ],
prev node: [ co ],
up to node: Function Index By Domain

Function Index By Domain [ cu ] to [ da ]

[ a ] [ ae ] [ ag ] [ al ] [ an ] [ ar ] [ b ] [ ba ] [ bi ] [ bo ] [ bs ] [ ca ] [ ch ] [ co ] [ cu ] [ da ] [ de ] [ di ] [ do ] [ dr ] [ dy ] [ ei ] [ em ] [ en ] [ er ] [ ev ] [ fi ] [ fm ] [ fo ] [ fr ] [ fu ] [ gr ] [ he ] [ ic ] [ im ] [ in ] [ is ] [ it ] [ jo ] [ ju ] [ ma ] [ me ] [ mi ] [ mo ] [ na ] [ op ] [ or ] [ ou ] [ pa ] [ pe ] [ po ] [ pr ] [ qu ] [ ra ] [ re ] [ ro ] [ sa ] [ sc ] [ se ] [ si ] [ sr ] [ st ] [ su ] [ ta ] [ te ] [ ti ] [ to ] [ tr ] [ un ] [ us ] [ ve ] [ vi ] [ vo ] [ wc ] [ wd ] [ wi ] [ wr ]

cu

cursor cursor cursor ** color ** color -> config
cursor cursor cursor -> config
cursor cursor? cursor -> bool
cursor name cursor -> denotation

da

dArray ! dArray ** nat -> data
dArray !? dArray ** nat -> option[data]
dArray # dArray -> nat
dArray := dArray ** nat ** data -> dArray
dArray abs? dArray -> bool
dArray def? nat ** dArray -> bool
dArray empty? dArray -> bool
dArray extend dArray ** nat ** (nat -> data) -> dArray
dArray extend dArray ** nat ** data -> dArray
dArray new dArray -> nat
dArray occ dArray -> set
dArray rep dArray -> array[data]
dArray swap dArray ** nat ** nat -> dArray
dArray upd nat ** (data -> data) ** dArray -> dArray
dArray upd nat ** data ** dArray -> dArray
dArray[data] / (data ** data -> data) ** dArray[data] -> data
dArray[data] \ (data ** data -> data) ** dArray[data] -> data
dArray[data] asArray dArray[data] -> array[data]
dArray[data] asSeq dArray[data] -> seq[data]
dArray[data] drop (data -> bool) ** dArray[data] -> dArray[data]
dArray[data] partition (data -> bool) ** dArray[data] -> dArray[data] ** dArray[data]
dArray[data] split (data -> bool) ** dArray[data] -> dArray[data] ** dArray[data]
dArray[data] take (data -> bool) ** dArray[data] -> dArray[data]
dArray[data] | (data -> bool) ** dArray[data] -> dArray[data]
dArray[from] * (from -> to) ** dArray[from] -> dArray[to]
dArray[from] / (from ** to -> to) ** to ** dArray[from] -> to
dArray[from] / (nat ** from ** to -> to) ** to ** dArray[from] -> to
dArray[from] \ (from ** to -> to) ** to ** dArray[from] -> to
dArray[from] \ (nat ** from ** to -> to) ** to ** dArray[from] -> to
data % (data -> bool) -> data ** data -> bool
data % data ** data ** data ** data ** data ** data ** data ** data -> bag
data % data ** data ** data ** data ** data ** data ** data ** data -> bstree
data % data ** data ** data ** data ** data ** data ** data ** data -> heap
data % data ** data ** data ** data ** data ** data ** data ** data -> seq
data % data ** data ** data ** data ** data ** data ** data ** data -> set : [1], [2]
data % data ** data ** data ** data ** data ** data ** data -> bag
data % data ** data ** data ** data ** data ** data ** data -> bstree
data % data ** data ** data ** data ** data ** data ** data -> heap
data % data ** data ** data ** data ** data ** data ** data -> seq
data % data ** data ** data ** data ** data ** data ** data -> set : [1], [2]
data % data ** data ** data ** data ** data ** data -> bag
data % data ** data ** data ** data ** data ** data -> bstree
data % data ** data ** data ** data ** data ** data -> heap
data % data ** data ** data ** data ** data ** data -> seq
data % data ** data ** data ** data ** data ** data -> set : [1], [2]
data % data ** data ** data ** data ** data -> bag
data % data ** data ** data ** data ** data -> bstree
data % data ** data ** data ** data ** data -> heap
data % data ** data ** data ** data ** data -> seq
data % data ** data ** data ** data ** data -> set : [1], [2]
data % data ** data ** data ** data -> bag
data % data ** data ** data ** data -> bstree
data % data ** data ** data ** data -> heap
data % data ** data ** data ** data -> seq
data % data ** data ** data ** data -> set : [1], [2]
data % data ** data ** data -> bag
data % data ** data ** data -> bstree
data % data ** data ** data -> heap
data % data ** data ** data -> seq
data % data ** data ** data -> set : [1], [2]
data % data ** data -> bag
data % data ** data -> bstree
data % data ** data -> heap
data % data ** data -> seq
data % data ** data -> set : [1], [2]
data % data -> bag
data % data -> bstree
data % data -> heap
data % data -> seq
data % data -> set : [1], [2]
data % data -> tree
data +% iseq ** data -> iseq
data +% seq ** data -> seq
data +%+ data -> seq ** seq -> seq
data +%+ data -> seq[data] ** iseq -> iseq
data ++ data ** bstree ** bstree -> bstree
data ++ data ** data -> data
data +/+ data -> seq ** seq -> seq
data +/+ data -> seq[data] ** iseq -> iseq
data / (data ** data -> data) ** array[data] -> data
data / (data ** data -> data) ** bag[data, <] -> data
data / (data ** data -> data) ** dArray[data] -> data
data / (data ** data -> data) ** seq[data] -> data
data / (data ** data -> data) ** set[data, <] -> data : [1], [2]
data / (dom ** codom ** data ** to -> to) ** to ** rel[dom, <, codom, <, data] -> to
data :: (() -> data) ** (() -> iseq) -> iseq
data :: (data ** data -> bool) ** (data ** data -> bool) -> data ** data -> bool
data :: (data -> bool) ** (data ** data -> bool) -> data ** data -> bool
data :: data ** iseq -> iseq
data :: data ** seq -> seq
data := array ** nat ** data -> array
data := dArray ** nat ** data -> dArray
data :=_val bstree ** data -> bstree
data :=_val heap ** data -> heap
data :=_val tree ** data -> tree
data < (data ** data -> bool) -> bstree ** bstree -> bool
data < (data ** data -> bool) -> heap ** heap -> bool
data < (data ** data -> bool) -> option ** option -> bool
data < (data ** data -> bool) -> seq ** seq -> bool
data < (data ** data -> bool) -> set ** set -> bool
data < (data ** data -> bool) -> tree ** tree -> bool
data < data ** data -> bool : [1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15], [16], [17], [18], [19], [20], [21], [22], [23], [24], [25], [26], [27], [28], [29]
data <= data ** data -> bool : [1], [2]
data = (data ** data -> bool) -> bstree ** bstree -> bool
data = (data ** data -> bool) -> heap ** heap -> bool
data = (data ** data -> bool) -> option ** option -> bool
data = (data ** data -> bool) -> seq ** seq -> bool
data = (data ** data -> bool) -> tree ** tree -> bool
data = data ** data -> bool : [1], [2]
data => stateId[state] ** (state -> state ** data) -> com[data]
data > data ** data -> bool : [1], [2]
data >= data ** data -> bool : [1], [2]
data ? stateId[state] ** (state -> data) -> com[data]
data @& (data -> com[void]) ** seq[data] -> com[void]
data @; (data -> com[void]) ** seq[data] -> com[void]
data \ (data ** data -> data) ** array[data] -> data
data \ (data ** data -> data) ** dArray[data] -> data
data \ (data ** data -> data) ** seq[data] -> data
data ^ (data -> data) ** nat -> data -> data
data ` (data -> denotation) -> ans[data] -> denotation
data ` (data -> denotation) -> array[data] -> denotation
data ` (data -> denotation) -> bag[data, <] -> denotation
data ` (data -> denotation) -> bstree[data, <] -> denotation
data ` (data -> denotation) -> dArray[data] -> denotation
data ` (data -> denotation) -> heap[data, <] -> denotation
data ` (data -> denotation) -> iseq[data] -> denotation
data ` (data -> denotation) -> option[data] -> denotation
data ` (data -> denotation) -> seq[data] -> denotation
data ` (data -> denotation) -> set[data, <] -> denotation : [1], [2]
data ` (data -> denotation) -> tree[data] -> denotation
data ` (data -> string) -> array[data] -> string
data ` (data -> string) -> bag[data, <] -> string
data ` (data -> string) -> bstree[data, <] -> string
data ` (data -> string) -> dArray[data] -> string
data ` (data -> string) -> heap[data, <] -> string
data ` (data -> string) -> iseq[data] -> string
data ` (data -> string) -> seq[data] -> string
data ` (data -> string) -> set[data, <] -> string : [1], [2]
data ` (data -> string) -> tree[data] -> string
data ` (dom -> denotation) ** (codom -> denotation) ** (data -> denotation) -> rel[dom, <, codom, <, data] -> denotation
data ` (dom -> string) ** (codom -> string) ** (data -> string) -> rel[dom, <, codom, <, data] -> string
data ` nat ** (data -> denotation) -> iseq[data] -> denotation
data ` nat ** (data -> string) -> iseq[data] -> string
data aEntry data ** config -> com[aEntry]
data aEntry data ** nat -> com[aEntry]
data aEntry data -> com[aEntry]
data aEntryLong data ** config -> com[aEntry]
data aEntryLong data ** nat -> com[aEntry]
data aEntryLong data -> com[aEntry]
data and (data -> bool) ** (data -> bool) -> data -> bool
data asSet (data -> bool) -> set
data avail data -> option
data await selector ** (data -> bool) -> com[data]
data bind aEntry ** event ** (aEntry ** eventInfo ** data -> com[void]) -> com[void] : [1], [2]
data bind emitter ** data -> config
data bind event ** emitter ** data -> com[void]
data bind event ** emitter ** data -> config
data bind event ** emitter ** data -> wconfig
data cmp (data ** data -> bool) -> option[data] ** option[data] -> rel
data cmp (data ** data -> bool) -> seq[data] ** seq[data] -> rel
data components (data ** data -> bool) -> seq[data] -> seq[seq[data]]
data cond (data -> bool) ** (data -> data) ** (data -> data) -> data -> data
data cons data ** iseq -> iseq
data cons data ** seq -> seq
data cont data -> option -> data
data ct data ** bag -> nat
data drop (data -> bool) ** array[data] -> array[data]
data drop (data -> bool) ** bstree[data, <] -> bstree[data, <]
data drop (data -> bool) ** dArray[data] -> dArray[data]
data drop (data -> bool) ** heap[data, <] -> heap[data, <]
data drop (data -> bool) ** iseq[data] -> iseq[data]
data drop (data -> bool) ** seq[data] -> seq[data]
data drop (data -> bool) ** tree[data] -> tree[data]
data dropall (data -> bool) ** bstree[data, <] -> bstree[data, <]
data dropall (data -> bool) ** heap[data, <] -> heap[data, <]
data dropall (data -> bool) ** tree[data] -> tree[data]
data emit dist ** data -> com[void]
data emit emitter ** data -> com[void]
data enable selector ** (data -> bool) -> config
data eq? (data ** data -> bool) -> option[data] ** option[data] -> bool
data eq? (data ** data -> bool) -> seq[data] ** seq[data] -> bool
data equal data ** data -> bool
data equiv data ** data -> bool
data excl data ** bag -> bag
data excl data ** bstree -> bstree
data excl data ** heap -> heap
data excl data ** set -> set : [1], [2]
data exclAll data ** bag -> bag
data exist1? (data -> bool) ** seq -> bool
data exist? (data -> bool) ** bag -> bool
data exist? (data -> bool) ** bstree -> bool
data exist? (data -> bool) ** heap -> bool
data exist? (data -> bool) ** seq -> bool
data exist? (data -> bool) ** set -> bool : [1], [2]
data exist? (data -> bool) ** tree -> bool
data exist? (dom ** codom ** data -> bool) ** rel -> bool
data extend array ** nat ** (nat -> data) -> array
data extend array ** nat ** data -> array
data extend dArray ** nat ** (nat -> data) -> dArray
data extend dArray ** nat ** data -> dArray
data extend rel ** seq[dom] ** seq[codom] ** (dom ** codom -> data) -> rel
data false data -> bool
data filter (data -> bool) ** seq[data] -> seq[data]
data filter (data -> bool) -> seq[data] -> seq[data]
data find? (data -> bool) ** bag -> option[data]
data find? (data -> bool) ** bstree -> option[data]
data find? (data -> bool) ** heap -> option[data]
data find? (data -> bool) ** iseq -> data
data find? (data -> bool) ** iseq -> option[data]
data find? (data -> bool) ** seq -> option[data]
data find? (data -> bool) ** set -> option[data] : [1], [2]
data find? (data -> bool) ** tree -> option[data]
data find? (dom ** codom ** data -> bool) ** rel -> option[triple[dom, codom, data]]
data fmtArray (data -> fmt) -> array[data] -> fmt
data fmtOption (data -> fmt) -> option[data] -> fmt
data fmtSeq (data -> fmt) -> seq[data] -> fmt
data fmtSet (data -> fmt) -> set[data, <] -> fmt
data for nat ** nat ** (nat ** data -> data) -> data -> data
data forall? (data -> bool) ** bag -> bool
data forall? (data -> bool) ** bstree -> bool
data forall? (data -> bool) ** heap -> bool
data forall? (data -> bool) ** seq -> bool
data forall? (data -> bool) ** set -> bool : [1], [2]
data forall? (data -> bool) ** tree -> bool
data forall? (dom ** codom ** data -> bool) ** rel -> bool
data gen data -> iseq
data get stateId[state] ** (state -> data) -> com[data]
data graphic (data -> denotation) -> bstree[data, <] -> denotation
data graphic (data -> denotation) -> heap[data, <] -> denotation
data graphic (data -> denotation) -> tree[data] -> denotation
data graphic (data -> string) -> bstree[data, <] -> string
data graphic (data -> string) -> heap[data, <] -> string
data graphic (data -> string) -> tree[data] -> string
data id data -> data
data in data ** bag -> bool
data in data ** bstree -> bool
data in data ** heap -> bool
data in data ** set -> bool : [1], [2], [3]
data incl data ** bag -> bag
data incl data ** bstree -> bstree
data incl data ** heap -> heap
data incl data ** set -> set : [1], [2]
data incl dom ** codom ** (dom ** codom -> data) ** rel -> rel
data incl dom ** codom ** data ** rel -> rel
data inclCt data ** nat ** bag -> bag
data init nat ** (nat -> data) -> array
data init nat ** (nat -> data) -> dArray
data init nat ** data -> array
data init nat ** data -> dArray
data inj data -> nat
data iter (data -> option[data] ** option[data]) ** option[data] -> bstree
data iter (data -> option[data] ** option[data]) ** option[data] -> heap
data iter (data -> option[data] ** option[data]) ** option[data] -> tree
data iter data ** (data -> data) ** (data -> bool) -> bag
data iter data ** (data -> data) ** (data -> bool) -> seq
data iter data ** (data -> data) ** (data -> bool) -> set : [1], [2]
data iter data ** (data -> data) -> iseq
data iter nat ** (data -> data) -> data -> data
data list (data -> fmt) ** fmt ** fmt ** fmt ** seq[data] -> fmt
data list (data -> fmt) ** fmt ** seq[data] -> fmt
data list? (data -> fmt) ** fmt ** fmt ** fmt ** seq[data] -> fmt
data merge (data ** data -> bool) -> iseq[data] ** iseq[data] -> iseq[data]
data merge (data ** data -> bool) -> seq[data] ** seq[data] -> seq[data]
data msort (data ** data -> bool) -> seq[data] -> seq[data]
data node data ** bstree ** bstree -> bstree
data node data ** heap ** heap -> heap
data node data ** tree ** tree -> tree
data okay data -> ans
data or (data -> bool) ** (data -> bool) -> data -> bool
data pack data ** denotation -> dyn
data partition (data ** data -> bool) -> seq[data] -> seq[seq[data]]
data partition (data ** data -> bool) -> set[data, <] -> set[set[data, <], {<}[data, <]] : [1], [2]
data partition (data -> bool) ** array[data] -> array[data] ** array[data]
data partition (data -> bool) ** bag[data, <] -> bag[data, <] ** bag[data, <]
data partition (data -> bool) ** dArray[data] -> dArray[data] ** dArray[data]
data partition (data -> bool) ** iseq[data] -> iseq[data] ** iseq[data]
data partition (data -> bool) ** seq[data] -> seq[data] ** seq[data]
data partition (data -> bool) ** set[data, <] -> set[data, <] ** set[data, <] : [1], [2]
data partition (data -> bool) ** set[data] -> set[data] ** set[data]
data partition (dom ** codom ** data -> bool) ** rel[dom, <, codom, <, data] -> rel[dom, <, codom, <, data] ** rel[dom, <, codom, <, data]
data pos (data -> bool) ** iseq[data] -> nat
data pos (data -> bool) ** iseq[data] -> option[nat]
data pos (data -> bool) ** seq[data] -> option[nat]
data PRINT bool ** (() -> denotation) ** data -> data
data PRINT bool ** (() -> fmt) ** data -> data
data PRINT bool ** (() -> string) ** data -> data
data PRINT bool ** denotation ** data -> data
data PRINT bool ** fmt ** data -> data
data PRINT bool ** string ** data -> data
data print data -> denotation : [1], [2], [3], [4], [5], [6]
data PRINT denotation ** (() -> denotation) ** data -> data
data PRINT denotation ** (() -> string) ** data -> data
data PRINT denotation ** denotation ** data -> data
data PRINT denotation ** string ** data -> data
data select selector ** (data -> bool) ** (data -> data) ** (data -> data) -> config
data select selector ** (data -> bool) ** data -> config
data selector data -> com[selector]
data set aEntry ** data -> com[void] : [1], [2]
data set selector ** data -> com[void]
data split (data -> bool) ** array[data] -> array[data] ** array[data]
data split (data -> bool) ** dArray[data] -> dArray[data] ** dArray[data]
data split (data -> bool) ** iseq[data] -> seq[data] ** iseq[data]
data split (data -> bool) ** seq[data] -> seq[data] ** seq[data]
data store denotation ** denotation ** data -> com[void]
data succeed data -> com
data succeed data -> parser
data sync aEntry ** (data -> com[void]) -> com[void] : [1], [2]
data sync selector ** (data -> bool) ** config ** config -> config
data take (data -> bool) ** array[data] -> array[data]
data take (data -> bool) ** bstree[data, <] -> bstree[data, <]
data take (data -> bool) ** dArray[data] -> dArray[data]
data take (data -> bool) ** heap[data, <] -> heap[data, <]
data take (data -> bool) ** iseq[data] -> seq[data]
data take (data -> bool) ** seq[data] -> seq[data]
data take (data -> bool) ** tree[data] -> tree[data]
data topSort (data -> set[data, <]) -> set[data, <] -> seq[set[data, <]]
data true data -> bool
data unequiv data ** data -> bool
data until (data -> bool) ** (data -> data) -> data -> data
data upd aEntry ** (data -> data) -> com[void] : [1], [2]
data upd nat ** (data -> data) ** array -> array
data upd nat ** (data -> data) ** bstree[data, <] -> bstree[data, <]
data upd nat ** (data -> data) ** dArray -> dArray
data upd nat ** (data -> data) ** heap[data, <] -> heap[data, <]
data upd nat ** (data -> data) ** iseq[data] -> iseq[data]
data upd nat ** (data -> data) ** seq[data] -> seq[data]
data upd nat ** (data -> data) ** tree[data] -> tree[data]
data upd nat ** data ** array -> array
data upd nat ** data ** bstree[data, <] -> bstree[data, <]
data upd nat ** data ** dArray -> dArray
data upd nat ** data ** heap[data, <] -> heap[data, <]
data upd nat ** data ** iseq[data] -> iseq[data]
data upd nat ** data ** seq[data] -> seq[data]
data upd nat ** data ** tree[data] -> tree[data]
data wEqual data ** data -> bool
data while (data -> bool) ** (data -> data) -> data -> data
data with stateId[state] ** (state -> state ** data) -> com[data]
data write file ** denotation ** data -> com[void]
data write output ** denotation ** data -> com[void]
data | (data -> bool) ** array[data] -> array[data]
data | (data -> bool) ** bag[data, <] -> bag[data, <]
data | (data -> bool) ** dArray[data] -> dArray[data]
data | (data -> bool) ** iseq[data] -> iseq[data]
data | (data -> bool) ** seq[data] -> seq[data]
data | (data -> bool) ** set[data, <] -> set[data, <] : [1], [2]
data | (data -> bool) ** set[data] -> set[data]
data | (dom ** codom ** data -> bool) ** rel[dom, <, codom, <, data] -> rel[dom, <, codom, <, data]
data |-> denotation ** data -> parser
data |= data ** data -> bool : [1], [2]
data ~ (data -> bool) -> data -> bool
data ~ data -> data
data1 & com[data1] ** (data1 -> data2) -> com[data2]
data1 & data1 ** data2 ** data3 ** data4 -> quad
data1 & data1 ** data2 ** data3 -> triple
data1 & data1 ** data2 -> pair
data1 & parser[data1] ** (data1 -> parser[data2]) -> parser[data2]
data1 & parser[data1] ** parser[void] ** (data1 -> parser[data2]) -> parser[data2]
data1 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** (data4 -> data41) ** quad[data1, data2, data3, data4] -> quad[data11, data21, data31, data41]
data1 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** triple[data1, data2, data3] -> triple[data11, data21, data31]
data1 * (data1 -> data11) ** (data2 -> data21) ** pair[data1, data2] -> pair[data11, data21]
data1 * (data1 -> data2) ** com[data1] -> com[data2]
data1 ++ data1 ** data2 -> data3
data1 1st data1 ** data2 ** data3 ** data4 -> data1
data1 1st data1 ** data2 ** data3 -> data1
data1 1st data1 ** data2 -> data1
data1 2nd data1 ** data2 ** data3 ** data4 -> data2
data1 2nd data1 ** data2 ** data3 -> data2
data1 2nd data1 ** data2 -> data2
data1 3rd data1 ** data2 ** data3 ** data4 -> data3
data1 3rd data1 ** data2 ** data3 -> data3
data1 4th data1 ** data2 ** data3 ** data4 -> data4
data1 < data1 ** data1 -> bool : [1], [2], [3], [4], [5], [6]
data1 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) ** (data4 -> denotation) -> quad[data1, data2, data3, data4] -> denotation
data1 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) ** (data4 -> denotation) -> union[data1, data2, data3, data4] -> denotation
data1 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) -> triple[data1, data2, data3] -> denotation
data1 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) -> union[data1, data2, data3] -> denotation
data1 ` (data1 -> denotation) ** (data2 -> denotation) -> pair[data1, data2] -> denotation
data1 ` (data1 -> denotation) ** (data2 -> denotation) -> union[data1, data2] -> denotation
data1 cmp (data1 ** data1 -> bool) ** (data2 ** data2 -> bool) -> pair[data1, data2] ** pair[data1, data2] -> rel
data1 data1 data1 -> union : [1], [2], [3]
data1 eq? (data1 ** data1 -> bool) ** (data2 ** data2 -> bool) -> pair[data1, data2] ** pair[data1, data2] -> bool
data1 f data1 -> data2
data1 fmtPair (data1 -> fmt) ** (data2 -> fmt) -> pair[data1, data2] -> fmt
data1 print1 data1 -> denotation : [1], [2]
data1 rel data1 ** data1 -> bool
data11 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** (data4 -> data41) ** quad[data1, data2, data3, data4] -> quad[data11, data21, data31, data41]
data11 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** triple[data1, data2, data3] -> triple[data11, data21, data31]
data11 * (data1 -> data11) ** (data2 -> data21) ** pair[data1, data2] -> pair[data11, data21]
data2 & com[data1] ** (data1 -> data2) -> com[data2]
data2 & data1 ** data2 ** data3 ** data4 -> quad
data2 & data1 ** data2 ** data3 -> triple
data2 & data1 ** data2 -> pair
data2 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** (data4 -> data41) ** quad[data1, data2, data3, data4] -> quad[data11, data21, data31, data41]
data2 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** triple[data1, data2, data3] -> triple[data11, data21, data31]
data2 * (data1 -> data11) ** (data2 -> data21) ** pair[data1, data2] -> pair[data11, data21]
data2 * (data1 -> data2) ** com[data1] -> com[data2]
data2 ++ data1 ** data2 -> data3
data2 1st data1 ** data2 ** data3 ** data4 -> data1
data2 1st data1 ** data2 ** data3 -> data1
data2 1st data1 ** data2 -> data1
data2 2nd data1 ** data2 ** data3 ** data4 -> data2
data2 2nd data1 ** data2 ** data3 -> data2
data2 2nd data1 ** data2 -> data2
data2 3rd data1 ** data2 ** data3 ** data4 -> data3
data2 3rd data1 ** data2 ** data3 -> data3
data2 4th data1 ** data2 ** data3 ** data4 -> data4
data2 < data2 ** data2 -> bool : [1], [2], [3], [4]
data2 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) ** (data4 -> denotation) -> quad[data1, data2, data3, data4] -> denotation
data2 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) ** (data4 -> denotation) -> union[data1, data2, data3, data4] -> denotation
data2 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) -> triple[data1, data2, data3] -> denotation
data2 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) -> union[data1, data2, data3] -> denotation
data2 ` (data1 -> denotation) ** (data2 -> denotation) -> pair[data1, data2] -> denotation
data2 ` (data1 -> denotation) ** (data2 -> denotation) -> union[data1, data2] -> denotation
data2 cmp (data1 ** data1 -> bool) ** (data2 ** data2 -> bool) -> pair[data1, data2] ** pair[data1, data2] -> rel
data2 data2 data2 -> union : [1], [2], [3]
data2 eq? (data1 ** data1 -> bool) ** (data2 ** data2 -> bool) -> pair[data1, data2] ** pair[data1, data2] -> bool
data2 fmtPair (data1 -> fmt) ** (data2 -> fmt) -> pair[data1, data2] -> fmt
data2 print2 data2 -> denotation : [1], [2]
data2 rel data2 ** data2 -> bool
data21 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** (data4 -> data41) ** quad[data1, data2, data3, data4] -> quad[data11, data21, data31, data41]
data21 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** triple[data1, data2, data3] -> triple[data11, data21, data31]
data21 * (data1 -> data11) ** (data2 -> data21) ** pair[data1, data2] -> pair[data11, data21]
data3 & data1 ** data2 ** data3 ** data4 -> quad
data3 & data1 ** data2 ** data3 -> triple
data3 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** (data4 -> data41) ** quad[data1, data2, data3, data4] -> quad[data11, data21, data31, data41]
data3 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** triple[data1, data2, data3] -> triple[data11, data21, data31]
data3 1st data1 ** data2 ** data3 ** data4 -> data1
data3 1st data1 ** data2 ** data3 -> data1
data3 2nd data1 ** data2 ** data3 ** data4 -> data2
data3 2nd data1 ** data2 ** data3 -> data2
data3 3rd data1 ** data2 ** data3 ** data4 -> data3
data3 3rd data1 ** data2 ** data3 -> data3
data3 4th data1 ** data2 ** data3 ** data4 -> data4
data3 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) ** (data4 -> denotation) -> quad[data1, data2, data3, data4] -> denotation
data3 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) ** (data4 -> denotation) -> union[data1, data2, data3, data4] -> denotation
data3 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) -> triple[data1, data2, data3] -> denotation
data3 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) -> union[data1, data2, data3] -> denotation
data3 data3 data3 -> union : [1], [2]
data31 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** (data4 -> data41) ** quad[data1, data2, data3, data4] -> quad[data11, data21, data31, data41]
data31 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** triple[data1, data2, data3] -> triple[data11, data21, data31]
data4 & data1 ** data2 ** data3 ** data4 -> quad
data4 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** (data4 -> data41) ** quad[data1, data2, data3, data4] -> quad[data11, data21, data31, data41]
data4 1st data1 ** data2 ** data3 ** data4 -> data1
data4 2nd data1 ** data2 ** data3 ** data4 -> data2
data4 3rd data1 ** data2 ** data3 ** data4 -> data3
data4 4th data1 ** data2 ** data3 ** data4 -> data4
data4 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) ** (data4 -> denotation) -> quad[data1, data2, data3, data4] -> denotation
data4 ` (data1 -> denotation) ** (data2 -> denotation) ** (data3 -> denotation) ** (data4 -> denotation) -> union[data1, data2, data3, data4] -> denotation
data4 data4 data4 -> union
data41 * (data1 -> data11) ** (data2 -> data21) ** (data3 -> data31) ** (data4 -> data41) ** quad[data1, data2, data3, data4] -> quad[data11, data21, data31, data41]
dataFrom * (domFrom ** codomFrom ** dataFrom -> domTo ** codomTo ** dataTo) ** rel[domFrom, <, codomFrom, <, dataFrom] -> rel[domTo, <, codomTo, <, dataTo]
dataFrom * (domFrom -> domTo) ** (codomFrom -> codomTo) ** (dataFrom -> dataTo) ** rel[domFrom, <, codomFrom, <, dataFrom] -> rel[domTo, <, codomTo, <, dataTo]
dataTo * (domFrom ** codomFrom ** dataFrom -> domTo ** codomTo ** dataTo) ** rel[domFrom, <, codomFrom, <, dataFrom] -> rel[domTo, <, codomTo, <, dataTo]
dataTo * (domFrom -> domTo) ** (codomFrom -> codomTo) ** (dataFrom -> dataTo) ** rel[domFrom, <, codomFrom, <, dataFrom] -> rel[domTo, <, codomTo, <, dataTo]

next node: [ de ],
prev node: [ co ],
up to node: Function Index By Domain