next node: [ me ] to [ na ],
prev node: [ ic ] to [ in ],
up to node: Function Index By Domain

Function Index By Domain [ is ] to [ ma ]

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

is

iseq +% iseq ** data -> iseq
iseq ++ iseq ** iseq -> iseq
iseq ++ seq[data] ** iseq -> iseq
iseq :: (() -> data) ** (() -> iseq) -> iseq
iseq :: data ** iseq -> iseq
iseq cons data ** iseq -> iseq
iseq drop nat ** iseq -> iseq
iseq find? (data -> bool) ** iseq -> data
iseq find? (data -> bool) ** iseq -> option[data]
iseq ft iseq -> data
iseq rt iseq -> iseq
iseq split nat ** iseq -> seq[data] ** iseq
iseq take nat ** iseq -> seq[data]
iseq[data] ! iseq[data] ** nat -> data
iseq[data] delete iseq[data] ** nat ** nat -> iseq[data]
iseq[data] drop (data -> bool) ** iseq[data] -> iseq[data]
iseq[data] insert iseq[data] ** nat ** seq[data] -> iseq[data]
iseq[data] partition (data -> bool) ** iseq[data] -> iseq[data] ** iseq[data]
iseq[data] pos (data -> bool) ** iseq[data] -> nat
iseq[data] pos (data -> bool) ** iseq[data] -> option[nat]
iseq[data] repl iseq[data] ** nat ** seq[data] -> iseq[data]
iseq[data] slice iseq[data] ** nat ** nat -> seq[data]
iseq[data] split (data -> bool) ** iseq[data] -> seq[data] ** iseq[data]
iseq[data] swap nat ** nat ** iseq[data] -> iseq[data]
iseq[data] take (data -> bool) ** iseq[data] -> seq[data]
iseq[data] upd nat ** (data -> data) ** iseq[data] -> iseq[data]
iseq[data] upd nat ** data ** iseq[data] -> iseq[data]
iseq[data] | (data -> bool) ** iseq[data] -> iseq[data]
iseq[from] * (env ** from -> env ** to) ** env ** iseq[from] -> iseq[to]
iseq[from] * (from -> to) ** iseq[from] -> iseq[to]

it

items ++ items ** items -> items
items menu items -> com[window]
items menu wconfig ** items -> com[window]
items menuButton items -> view
items menuButton wconfig ** items -> view
items submenu items -> config
items submenu wconfig ** items -> config
items with items ** config -> items

jo

joinStyle bevel? joinStyle -> bool
joinStyle join joinStyle -> config
joinStyle miter? joinStyle -> bool
joinStyle round? joinStyle -> bool

ju

justifyHow center? justifyHow -> bool
justifyHow justify justifyHow -> config
justifyHow left? justifyHow -> bool
justifyHow right? justifyHow -> bool

ma

manager external? manager -> bool
manager internal? manager -> bool
manager manager manager -> wconfig
managerRequest get window ** managerRequest -> com[manager]
managerRequest manager? managerRequest -> bool
map ! map ** dom -> codom : [1], [2], [3]
map !? map ** dom -> option[codom] : [1], [2], [3]
map # map -> nat : [1], [2], [3]
map <+ map ** map -> map : [1], [2], [3]
map <- map ** set[dom, <] -> map : [1], [2], [3]
map codom map -> seq[codom] : [1], [2], [3]
map def dom ** codom ** map -> map : [1], [2], [3]
map def? dom ** map -> bool : [1], [2], [3]
map dom map -> set[dom, <] : [1], [2], [3]
map exist? (dom ** codom -> bool) ** map -> bool : [1], [2], [3]
map extend map ** seq[dom] ** seq[codom] -> map : [1], [2], [3]
map find? (dom ** codom -> bool) ** map -> option[pair[dom, codom]] : [1], [2], [3]
map forall? (dom ** codom -> bool) ** map -> bool : [1], [2], [3]
map rep map -> set[pair[dom, codom], less] : [1], [2]
map undef dom ** map -> map : [1], [2], [3]
map upd dom ** (codom -> codom) ** map -> map : [1], [2], [3]
map {}? map -> bool : [1], [2], [3]
map[data, <, set[data, <]] msc map[data, <, set[data, <]] -> seq[seq[data]]
map[data1, <, data2] bind mapEntry ** event ** (mapEntry ** eventInfo ** map[data1, <, data2] -> com[void]) -> com[void] : [1], [2]
map[data1, <, data2] mapEntry map[data1, <, data2] ** config -> com[mapEntry]
map[data1, <, data2] mapEntry map[data1, <, data2] ** nat ** nat -> com[mapEntry]
map[data1, <, data2] mapEntry map[data1, <, data2] -> com[mapEntry]
map[data1, <, data2] set mapEntry ** map[data1, <, data2] -> com[void] : [1], [2]
map[data1, <, data2] sync mapEntry ** (map[data1, <, data2] -> com[void]) -> com[void] : [1], [2]
map[data1, <, data2] upd mapEntry ** (map[data1, <, data2] -> map[data1, <, data2]) -> com[void] : [1], [2]
map[dom, <, codom] / (codom ** to -> to) ** to ** map[dom, <, codom] -> to : [1], [2], [3]
map[dom, <, codom] / (dom ** codom ** to -> to) ** to ** map[dom, <, codom] -> to : [1], [2], [3]
map[dom, <, codom] asSeq map[dom, <, codom] -> seq[pair[dom, codom]] : [1], [2], [3]
map[dom, <, codom] explode map[dom, <, codom] -> seq[pair[dom, codom]] : [1], [2]
map[dom, <, codom] invert map[dom, <, codom] -> map[codom, <, dom] : [1], [2], [3]
map[dom, <, codom] partition (dom ** codom -> bool) ** map[dom, <, codom] -> map[dom, <, codom] ** map[dom, <, codom] : [1], [2], [3]
map[dom, <, codom] rep map[dom, <, codom] -> set[pair[dom, codom], less]
map[dom, <, codom] | (dom ** codom -> bool) ** map[dom, <, codom] -> map[dom, <, codom] : [1], [2], [3]
map[dom, <, codomFrom] * (codomFrom -> codomTo) ** map[dom, <, codomFrom] -> map[dom, <, codomTo] : [1], [2], [3]
map[dom, <, interdom] o map[dom, <, interdom] ** map[interdom, <, codom] -> map[dom, <, codom] : [1], [2], [3]
map[dom, <, map[codom, <, data]] abs map[dom, <, map[codom, <, data]] -> rel[dom, <, codom, <, data]
map[interdom, <, codom] o map[dom, <, interdom] ** map[interdom, <, codom] -> map[dom, <, codom] : [1], [2], [3]
mapEntry bind mapEntry ** event ** (mapEntry ** eventInfo ** map[data1, <, data2] -> com[void]) -> com[void] : [1], [2]
mapEntry bind mapEntry ** event ** (mapEntry ** eventInfo -> com[void]) -> com[void] : [1], [2]
mapEntry get mapEntry ** point -> com[pair[data1, data2]] : [1], [2]
mapEntry get mapEntry -> com[map[data1, <, data2]] : [1], [2]
mapEntry getSelection mapEntry -> com[map[data1, <, data2]] : [1], [2]
mapEntry regulator1 mapEntry -> regulator : [1], [2]
mapEntry regulator2 mapEntry -> regulator : [1], [2]
mapEntry set mapEntry ** map[data1, <, data2] -> com[void] : [1], [2]
mapEntry sync mapEntry ** (map[data1, <, data2] -> com[void]) -> com[void] : [1], [2]
mapEntry upd mapEntry ** (map[data1, <, data2] -> map[data1, <, data2]) -> com[void] : [1], [2]
mapEntry view mapEntry -> view : [1], [2]
mark at mark -> index
mark delete textEditor ** mark -> com[void]
mark move textEditor ** mark ** index -> com[void]

next node: [ me ] to [ na ],
prev node: [ ic ] to [ in ],
up to node: Function Index By Domain