next node: [ si ],
prev node: [ qu ] to [ re ],
up to node: Function Index By Domain

Function Index By Domain [ ro ] to [ se ]

[ 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 ]

ro

role client? role -> bool
role open denotation ** role -> com[channel]
role server? role -> bool

sa

sap => sap ** (in -> bool) ** (in -> com[out]) -> com[out]
sap => sap ** (in -> com[out]) -> com[out]
sap @ sap ** in -> com[out]
sap[in, out] ` sap[in, out] -> denotation

sc

script & script ** denotation -> script
script & script ** int -> script
script & script ** nat -> script
script & script ** real -> script
script & script ** string -> script
script + script ** callback -> script
script + script ** denotation -> script
script + script ** nat -> script
script + script ** real -> script
script + script ** string -> script
script + script ** widget -> script
script act script -> com[void]
script config script -> config
script doConfig window ** widget ** modifier ** script -> com[void]
script eval script -> com[string]
script format script -> string
script formatS script -> string
scroller awaitView scroller -> com[scrollView]
scroller awaitWindow scroller -> com[scrollWindow]
scroller scroll scroller ** orient -> config
scroller scrollControl scroller -> config
scroller setView scroller ** scrollView -> com[void]
scroller setWindow scroller ** scrollWindow -> com[void]
scrollView int scrollView -> int
scrollView moveto? scrollView -> bool
scrollView pos scrollView -> real
scrollView setView scroller ** scrollView -> com[void]
scrollView shiftPages? scrollView -> bool
scrollView shiftUnits? scrollView -> bool
scrollWindow first scrollWindow -> real
scrollWindow last scrollWindow -> real
scrollWindow setWindow scroller ** scrollWindow -> com[void]
scrollWindow window? scrollWindow -> bool

se

searchOpt backwards? searchOpt -> bool
searchOpt exact? searchOpt -> bool
searchOpt forwards? searchOpt -> bool
searchOpt nocase? searchOpt -> bool
searchOpt regexp? searchOpt -> bool
seekMode fromCurrent? seekMode -> bool
seekMode fromEnd? seekMode -> bool
seekMode fromStart? seekMode -> bool
seekMode seek file ** int ** seekMode -> com[void]
selector await selector ** (data -> bool) -> com[data]
selector enable selector ** (data -> bool) -> config
selector get selector -> com[data]
selector select selector ** (data -> bool) ** (data -> data) ** (data -> data) -> config
selector select selector ** (data -> bool) ** data -> config
selector set selector ** data -> com[void]
selector sync selector ** (data -> bool) ** config ** config -> config
semaphor atomic semaphor ** com[void] -> com[void]
semaphor release semaphor -> com[void]
semaphor reserve semaphor -> com[void]
seq # seq -> nat
seq +% seq ** data -> seq
seq +%+ seq -> seq ** seq -> seq
seq ++ seq ** seq -> seq
seq +/+ seq -> seq ** seq -> seq
seq :: data ** seq -> seq
seq ::? seq -> bool
seq <>? seq -> bool
seq cons data ** seq -> seq
seq cons? seq -> bool
seq drop nat ** seq -> seq
seq empty? seq -> bool
seq exist1? (data -> bool) ** seq -> bool
seq exist? (data -> bool) ** seq -> bool
seq find? (data -> bool) ** seq -> option[data]
seq forall? (data -> bool) ** seq -> bool
seq front seq -> seq
seq ft seq -> data
seq last seq -> data
seq revert seq -> seq
seq rt seq -> seq
seq split nat ** seq -> seq ** seq
seq take nat ** seq -> seq
seq[char] asString seq[char] -> string
seq[char] implode seq[char] -> string
seq[codom] extend map ** seq[dom] ** seq[codom] -> map : [1], [2], [3]
seq[codom] extend natMap ** seq[nat] ** seq[codom] -> natMap
seq[codom] extend rel ** seq[dom] ** seq[codom] ** (dom ** codom -> data) -> rel
seq[codom] extend rel ** seq[dom] ** seq[codom] ** seq[data] -> rel
seq[configCom] config seq[configCom] -> config
seq[data] ! seq[data] ** nat -> data
seq[data] +%+ seq[data] -> seq[data] ** iseq -> iseq
seq[data] ++ seq[data] ** iseq -> iseq
seq[data] +/+ seq[data] -> seq[data] ** iseq -> iseq
seq[data] / (data ** data -> data) ** seq[data] -> data
seq[data] @& (data -> com[void]) ** seq[data] -> com[void]
seq[data] @; (data -> com[void]) ** seq[data] -> com[void]
seq[data] \ (data ** data -> data) ** seq[data] -> data
seq[data] abs seq[data] -> set
seq[data] asArray seq[data] -> array[data]
seq[data] asBag seq[data] -> bag[data, <]
seq[data] asDArray seq[data] -> dArray[data]
seq[data] asSet seq[data] -> set[data, <] : [1], [2]
seq[data] bind seqEntry ** event ** (seqEntry ** eventInfo ** seq[data] -> com[void]) -> com[void] : [1], [2]
seq[data] delete seq[data] ** nat ** nat -> seq[data]
seq[data] drop (data -> bool) ** seq[data] -> seq[data]
seq[data] extend rel ** seq[dom] ** seq[codom] ** seq[data] -> rel
seq[data] filter (data -> bool) ** seq[data] -> seq[data]
seq[data] implode seq[data] -> bag[data, <]
seq[data] inits seq[data] -> seq[seq[data]]
seq[data] insert iseq[data] ** nat ** seq[data] -> iseq[data]
seq[data] insert seq[data] ** nat ** seq[data] -> seq[data]
seq[data] list (data -> fmt) ** fmt ** fmt ** fmt ** seq[data] -> fmt
seq[data] list (data -> fmt) ** fmt ** seq[data] -> fmt
seq[data] list? (data -> fmt) ** fmt ** fmt ** fmt ** seq[data] -> fmt
seq[data] partition (data -> bool) ** seq[data] -> seq[data] ** seq[data]
seq[data] permutations seq[data] -> seq[seq[data]]
seq[data] pos (data -> bool) ** seq[data] -> option[nat]
seq[data] repeat seq[data] -> iseq
seq[data] repl iseq[data] ** nat ** seq[data] -> iseq[data]
seq[data] repl seq[data] ** nat ** seq[data] -> seq[data]
seq[data] seqEntry seq[data] ** config -> com[seqEntry]
seq[data] seqEntry seq[data] ** nat ** nat -> com[seqEntry]
seq[data] seqEntry seq[data] -> com[seqEntry]
seq[data] set seqEntry ** seq[data] -> com[void] : [1], [2]
seq[data] slice seq[data] ** nat ** nat -> seq[data]
seq[data] split (data -> bool) ** seq[data] -> seq[data] ** seq[data]
seq[data] swap nat ** nat ** seq[data] -> seq[data]
seq[data] sync seqEntry ** (seq[data] -> com[void]) -> com[void] : [1], [2]
seq[data] tails seq[data] -> seq[seq[data]]
seq[data] take (data -> bool) ** seq[data] -> seq[data]
seq[data] upd nat ** (data -> data) ** seq[data] -> seq[data]
seq[data] upd nat ** data ** seq[data] -> seq[data]
seq[data] upd seqEntry ** (seq[data] -> seq[data]) -> com[void] : [1], [2]
seq[data] | (data -> bool) ** seq[data] -> seq[data]
seq[denotation] exec denotation ** seq[denotation] -> com[void]
seq[denotation] execE denotation ** seq[denotation] ** seq[denotation] -> com[void]
seq[denotation] execP denotation ** seq[denotation] -> com[void]
seq[denotation] setArgs seq[denotation] -> com[void]
seq[doc] cat seq[doc] -> doc
seq[doc] fill seq[doc] -> doc
seq[doc] hcat seq[doc] -> doc
seq[doc] hsep seq[doc] -> doc
seq[doc] punctuate doc ** seq[doc] -> seq[doc]
seq[doc] sep seq[doc] -> doc
seq[doc] vcat seq[doc] -> doc
seq[dom] extend map ** seq[dom] ** seq[codom] -> map : [1], [2], [3]
seq[dom] extend rel ** seq[dom] ** seq[codom] ** (dom ** codom -> data) -> rel
seq[dom] extend rel ** seq[dom] ** seq[codom] ** seq[data] -> rel
seq[fmt] ..* seq[fmt] -> fmt
seq[fmt] ..|..* fmt ** seq[fmt] -> fmt
seq[from] * (env ** from -> env ** to) ** env ** seq[from] -> env ** seq[to]
seq[from] * (from -> to) ** seq[from] -> seq[to]
seq[from] *& (from -> com[to]) ** seq[from] -> com[seq[to]]
seq[from] / (from ** ans[to] -> com[to]) ** ans[to] ** seq[from] -> com[to]
seq[from] / (from ** to -> to) ** to ** seq[from] -> to
seq[from] /& (from ** to -> com[to]) ** to ** seq[from] -> com[to]
seq[from] // (from ** ans[to] -> com[to]) ** seq[from] -> ans[to] -> com[to]
seq[from] \ (from ** to -> to) ** to ** seq[from] -> to
seq[from] map (from -> to) ** seq[from] -> seq[to]
seq[from] reduce (from ** to -> to) ** to ** seq[from] -> to
seq[nat] asSet seq[nat] -> set
seq[nat] extend natMap ** seq[nat] ** seq[codom] -> natMap
seq[pair[data, nat]] abs seq[pair[data, nat]] -> bag
seq[pair[data, nat]] asBag seq[pair[data, nat]] -> bag[data, <]
seq[pair[data, nat]] implodeCt seq[pair[data, nat]] -> bag[data, <]
seq[pair[denotation, com[void]]] menu denotation ** seq[pair[denotation, com[void]]] -> com[void]
seq[pair[dom, codom]] asMap seq[pair[dom, codom]] -> map[dom, <, codom] : [1], [2], [3]
seq[pair[dom, codom]] implode seq[pair[dom, codom]] -> map[dom, <, codom] : [1], [2]
seq[pair[nat, codom]] asNatMap seq[pair[nat, codom]] -> natMap[codom]
seq[point] line seq[point] -> drawing
seq[point] polygon seq[point] -> drawing
seq[range] delete textEditor ** seq[range] -> com[void]
seq[range] tag textEditor ** seq[range] ** tag -> com[void]
seq[range] untag textEditor ** seq[range] ** tag -> com[void]
seq[searchOpt] search textEditor ** denotation ** index ** seq[searchOpt] -> com[option[index]]
seq[seq[data]] combinations seq[seq[data]] -> seq[seq[data]]
seq[seq[data]] flat seq[seq[data]] -> seq[data]
seq[seq[data]] transpose seq[seq[data]] -> seq[seq[data]]
seq[string] @ interpreter ** seq[string] -> com[string]
seq[string] asString seq[string] -> string
seq[string] define (seq[string] -> com[string]) -> com[callback]
seq[string] define callback ** (seq[string] -> com[string]) -> com[void]
seq[string] define interpreter ** denotation ** (interpreter ** seq[string] -> ans[string]) -> com[void]
seq[string] define interpreter ** denotation ** (interpreter ** seq[string] -> com[string]) -> com[void]
seq[string] execve denotation ** seq[string] ** option[seq[string]] -> com[void]
seq[string] extDefine callback ** (seq[string] -> com[void]) -> com[void]
seq[string] store denotation ** seq[string] -> com[void]
seq[string] writeLines file ** seq[string] -> com[void]
seq[string] writeLines output ** seq[string] -> com[void]
seq[token] parser (seq[token] ** state -> either[option[error], a] ** seq[token] ** state) -> parser
seq[token] run seq[token] ** state ** (() -> parser) -> either[option[error], a]
seq[triple[dom, codom, data]] asRel seq[triple[dom, codom, data]] -> rel[dom, <, codom, <, data]
seq[union] @ interpreter ** denotation ** seq[union] -> com[string]
seq[union] ` seq[union] -> denotation
seq[union] format denotation ** seq[union] -> string
seq[union] format string ** seq[union] -> string
seq[union] text denotation ** seq[union] -> config
seq[union] u bool ** seq[union] -> seq[union]
seq[union] u char ** seq[union] -> seq[union]
seq[union] u denotation ** seq[union] -> seq[union]
seq[union] u int ** seq[union] -> seq[union]
seq[union] u nat ** seq[union] -> seq[union]
seq[union] u real ** seq[union] -> seq[union]
seq[union] u string ** seq[union] -> seq[union]
seq[view] compound composeOp ** seq[view] -> view
seq[view] displayChildren window ** widget ** string ** seq[view] -> com[bool]
seq[wconfigCom] wconfig seq[wconfigCom] -> wconfig
seqEntry bind seqEntry ** event ** (seqEntry ** eventInfo ** seq[data] -> com[void]) -> com[void] : [1], [2]
seqEntry bind seqEntry ** event ** (seqEntry ** eventInfo -> com[void]) -> com[void] : [1], [2]
seqEntry get seqEntry ** point -> com[pair[nat, data]] : [1], [2]
seqEntry get seqEntry -> com[seq[data]] : [1], [2]
seqEntry getSelection seqEntry -> com[seq[data]] : [1], [2]
seqEntry regulator seqEntry -> regulator : [1], [2]
seqEntry set seqEntry ** seq[data] -> com[void] : [1], [2]
seqEntry sync seqEntry ** (seq[data] -> com[void]) -> com[void] : [1], [2]
seqEntry upd seqEntry ** (seq[data] -> seq[data]) -> com[void] : [1], [2]
seqEntry view seqEntry -> view : [1], [2]
set # set -> nat : [1], [2], [3]
set * (nat -> nat) ** set -> set
set * set ** set -> set : [1], [2], [3], [4]
set + set ** set -> set : [1], [2], [3], [4]
set - set ** set -> set : [1], [2], [3], [4]
set / (nat ** nat -> nat) ** set -> nat
set / (nat ** to -> to) ** to ** set -> to
set < set ** set -> bool : [1], [2], [3]
set <= set ** set -> bool : [1], [2], [3]
set = set ** set -> bool : [1], [2], [3]
set ` set -> denotation
set ` set -> string
set abs array[data] ** set ** nat -> dArray
set arb set -> data : [1], [2]
set arb set -> nat
set asSeq set -> seq[nat]
set asSet? set -> bool
set cF set -> data -> bool
set excl data ** set -> set : [1], [2]
set excl nat ** set -> set
set exist? (data -> bool) ** set -> bool : [1], [2]
set exist? (nat -> bool) ** set -> bool
set find? (data -> bool) ** set -> option[data] : [1], [2]
set find? (nat -> bool) ** set -> option[nat]
set forall? (data -> bool) ** set -> bool : [1], [2]
set forall? (nat -> bool) ** set -> bool
set in data ** set -> bool : [1], [2], [3]
set in nat ** set -> bool
set incl data ** set -> set : [1], [2]
set incl nat ** set -> set
set max set -> data : [1], [2]
set min set -> data : [1], [2]
set partition (nat -> bool) ** set -> set ** set
set rep set -> bstree[data, <]
set rep set -> seq[data]
set {<} set ** set -> bool : [1], [2], [3]
set {}? set -> bool : [1], [2], [3]
set | (nat -> bool) ** set -> set
set ~ set -> set
set[codom, <] !_c rel ** set[codom, <] -> set[dom, <]
set[codom, <] x dom ** set[codom, <] -> (dom ** codom -> data) -> rel
set[codom, <] x set[dom, <] ** set[codom, <] -> (dom ** codom -> data) -> rel
set[codom, <] |> rel ** set[codom, <] -> rel
set[codom, <] |~> rel ** set[codom, <] -> rel
set[data, <] / (data ** data -> data) ** set[data, <] -> data : [1], [2]
set[data, <] asSeq set[data, <] -> seq[data] : [1], [2]
set[data, <] bind setEntry ** event ** (setEntry ** eventInfo ** set[data, <] -> com[void]) -> com[void] : [1], [2]
set[data, <] P set[data, <] -> set[set[data, <], {<}[data, <]] : [1], [2]
set[data, <] partition (data -> bool) ** set[data, <] -> set[data, <] ** set[data, <] : [1], [2]
set[data, <] set setEntry ** set[data, <] -> com[void] : [1], [2]
set[data, <] setEntry set[data, <] ** config -> com[setEntry]
set[data, <] setEntry set[data, <] ** nat ** nat -> com[setEntry]
set[data, <] setEntry set[data, <] -> com[setEntry]
set[data, <] sync setEntry ** (set[data, <] -> com[void]) -> com[void] : [1], [2]
set[data, <] topSort (data -> set[data, <]) -> set[data, <] -> seq[set[data, <]]
set[data, <] upd setEntry ** (set[data, <] -> set[data, <]) -> com[void] : [1], [2]
set[data, <] | (data -> bool) ** set[data, <] -> set[data, <] : [1], [2]
set[data1, <] U set[data1, <] ** set[data2, <] -> set[union[data1, data2], <] : [1], [2]
set[data1, <] x set[data1, <] ** set[data2, <] -> set[pair[data1, data2], <] : [1], [2]
set[data1] U set[data1] ** set[data2] -> set[union[data1, data2]]
set[data1] x set[data1] ** set[data2] -> set[pair[data1, data2]]
set[data2, <] U set[data1, <] ** set[data2, <] -> set[union[data1, data2], <] : [1], [2]
set[data2, <] x set[data1, <] ** set[data2, <] -> set[pair[data1, data2], <] : [1], [2]
set[data2] U set[data1] ** set[data2] -> set[union[data1, data2]]
set[data2] x set[data1] ** set[data2] -> set[pair[data1, data2]]
set[data] ` set[data] -> denotation
set[data] ` set[data] -> string
set[data] partition (data -> bool) ** set[data] -> set[data] ** set[data]
set[data] | (data -> bool) ** set[data] -> set[data]
set[dom, <] ! rel ** set[dom, <] -> set[codom, <]
set[dom, <] <- map ** set[dom, <] -> map : [1], [2], [3]
set[dom, <] <| set[dom, <] ** rel -> rel
set[dom, <] <~| set[dom, <] ** rel -> rel
set[dom, <] id set[dom, <] -> rel[dom, <, dom, <, data]
set[dom, <] init set[dom, <] ** (dom -> codom) -> map : [1], [2], [3]
set[dom, <] x set[dom, <] ** codom -> (dom ** codom -> data) -> rel
set[dom, <] x set[dom, <] ** set[codom, <] -> (dom ** codom -> data) -> rel
set[from, <] * (env ** from -> env ** to) ** env ** set[from, <] -> env ** set[to, <] : [1], [2]
set[from, <] * (from -> to) ** set[from, <] -> set[to, <] : [1], [2]
set[from, <] / (from ** to -> to) ** to ** set[from, <] -> to : [1], [2]
set[nat, <] <- natMap ** set[nat, <] -> natMap
set[nat, <] init set[nat, <] ** (nat -> codom) -> natMap
set[packOp, <] horizontal set[packOp, <] -> composeOp
set[packOp, <] modified set[packOp, <] ** view -> view
set[packOp, <] vertical set[packOp, <] -> composeOp
set[pair[dom, codom], less] abs set[pair[dom, codom], less] -> map : [1], [2]
set[pair[dom, codom], less] abs set[pair[dom, codom], less] -> map[dom, <, codom]
set[set[data, <], {<}[data, <]] flat set[set[data, <], {<}[data, <]] -> set[data, <] : [1], [2]
set[tag, <] addTags set[tag, <] -> config
set[tag, <] tags set[tag, <] -> config
setEntry bind setEntry ** event ** (setEntry ** eventInfo ** set[data, <] -> com[void]) -> com[void] : [1], [2]
setEntry bind setEntry ** event ** (setEntry ** eventInfo -> com[void]) -> com[void] : [1], [2]
setEntry get setEntry ** point -> com[data] : [1], [2]
setEntry get setEntry -> com[set[data, <]] : [1], [2]
setEntry getSelection setEntry -> com[set[data, <]] : [1], [2]
setEntry regulator setEntry -> regulator : [1], [2]
setEntry set setEntry ** set[data, <] -> com[void] : [1], [2]
setEntry sync setEntry ** (set[data, <] -> com[void]) -> com[void] : [1], [2]
setEntry upd setEntry ** (set[data, <] -> set[data, <]) -> com[void] : [1], [2]
setEntry view setEntry -> view : [1], [2]

next node: [ si ],
prev node: [ qu ] to [ re ],
up to node: Function Index By Domain