next node: [ pe ] to [ re ],
prev node: [ mo ] to [ na ],
up to node: Function Index By Codomain

Function Index By Codomain [ op ] to [ pa ]

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

op

option < (data ** data -> bool) -> option ** option -> bool
option = (data ** data -> bool) -> option ** option -> bool
option avail data -> option
option cont data -> option -> data
option nil option
option[bool] dst? time -> option[bool]
option[bool] scan string -> option[bool] ** string
option[bstree[data, <]] !? bstree[data, <] ** nat -> option[bstree[data, <]]
option[char] find? (char -> bool) ** string -> option[char]
option[char] scan string -> option[char] ** string
option[codom] !? map ** dom -> option[codom] : [1], [2], [3]
option[codom] !? natMap ** nat -> option[codom]
option[data] !? bstree[data, <] ** nat -> option[data]
option[data] !? dArray ** nat -> option[data]
option[data] !? heap[data, <] ** nat -> option[data]
option[data] !? rel ** dom ** codom -> option[data]
option[data] !? tree[data] ** nat -> option[data]
option[data] @ parser ** string -> option[data]
option[data] ` (data -> denotation) -> option[data] -> denotation
option[data] asFct parser -> string -> option[data] ** string
option[data] cmp (data ** data -> bool) -> option[data] ** option[data] -> rel
option[data] eq? (data ** data -> bool) -> option[data] ** option[data] -> bool
option[data] find? (data -> bool) ** bag -> option[data]
option[data] find? (data -> bool) ** bstree -> option[data]
option[data] find? (data -> bool) ** heap -> option[data]
option[data] find? (data -> bool) ** iseq -> option[data]
option[data] find? (data -> bool) ** seq -> option[data]
option[data] find? (data -> bool) ** set -> option[data] : [1], [2]
option[data] find? (data -> bool) ** tree -> option[data]
option[data] fmtOption (data -> fmt) -> option[data] -> fmt
option[data] tryUnpack dyn ** denotation -> option[data]
option[denotation] applEnv denotation -> option[denotation]
option[heap[data, <]] !? heap[data, <] ** nat -> option[heap[data, <]]
option[int] scan string -> option[int] ** string
option[nat] find? (nat -> bool) ** set -> option[nat]
option[nat] pos (char -> bool) ** string -> option[nat]
option[nat] pos (data -> bool) ** iseq[data] -> option[nat]
option[nat] pos (data -> bool) ** seq[data] -> option[nat]
option[nat] scan string -> option[nat] ** string
option[pair[dom, codom]] find? (dom ** codom -> bool) ** map -> option[pair[dom, codom]] : [1], [2], [3]
option[pair[dom, codom]] find? (dom ** codom -> bool) ** rel -> option[pair[dom, codom]]
option[pair[nat, codom]] find? (nat ** codom -> bool) ** natMap -> option[pair[nat, codom]]
option[real] scan string -> option[real] ** string
option[res] * (arg -> res) ** option[arg] -> option[res]
option[seq[union]] scan denotation ** string -> option[seq[union]]
option[tree[data]] !? tree[data] ** nat -> option[tree[data]]
option[triple[dom, codom, data]] find? (dom ** codom ** data -> bool) ** rel -> option[triple[dom, codom, data]]

or

orient horizontal orient
orient vertical orient

ou

output abs file -> output
output stdErr output
output stdOut output

pa

packOp anchor_center packOp
packOp anchor_e packOp
packOp anchor_n packOp
packOp anchor_ne packOp
packOp anchor_nw packOp
packOp anchor_s packOp
packOp anchor_se packOp
packOp anchor_sw packOp
packOp anchor_w packOp
packOp expand packOp
packOp fillX packOp
packOp fillY packOp
packOp side_bottom packOp
packOp side_left packOp
packOp side_right packOp
packOp side_top packOp
pair & data1 ** data2 -> pair
pair[data1, data2] ` (data1 -> denotation) ** (data2 -> denotation) -> pair[data1, data2] -> denotation
pair[data1, data2] ` denotation ** denotation ** denotation -> (data1 -> denotation) ** (data2 -> denotation) -> pair[data1, data2] -> denotation
pair[data1, data2] cmp (data1 ** data1 -> bool) ** (data2 ** data2 -> bool) -> pair[data1, data2] ** pair[data1, data2] -> rel
pair[data1, data2] eq? (data1 ** data1 -> bool) ** (data2 ** data2 -> bool) -> pair[data1, data2] ** pair[data1, data2] -> bool
pair[data1, data2] fmtPair (data1 -> fmt) ** (data2 -> fmt) -> pair[data1, data2] -> fmt
pair[data11, data21] * (data1 -> data11) ** (data2 -> data21) ** pair[data1, data2] -> pair[data11, data21]
pair[nat, nat] defaultDim pair[nat, nat] : [1], [2], [3], [4], [5], [6]
parser asParser (string -> option[data] ** string) -> parser
parser break parser
parser eps a -> () -> parser
parser fail error -> () -> parser
parser parser (seq[token] ** state -> either[option[error], a] ** seq[token] ** state) -> parser
parser succeed data -> parser
parser | parser ** parser -> parser
parser |-> denotation ** data -> parser
parser[a, token, state, error] << (() -> parser[a, token, state, error]) ** (() -> parser[b, token, state, error]) -> () -> parser[a, token, state, error]
parser[a, token, state, error] | (() -> parser[a, token, state, error]) ** (() -> parser[a, token, state, error]) -> () -> parser[a, token, state, error]
parser[a, token, state, error] |^ (() -> parser[a, token, state, error]) ** (() -> parser[a, token, state, error]) -> () -> parser[a, token, state, error]
parser[b, token, state, error] & (() -> parser[a, token, state, error]) ** (a -> () -> parser[b, token, state, error]) -> () -> parser[b, token, state, error]
parser[b, token, state, error] * (() -> parser[a, token, state, error]) ** (a -> b) -> () -> parser[b, token, state, error]
parser[b, token, state, error] >> (() -> parser[a, token, state, error]) ** (() -> parser[b, token, state, error]) -> () -> parser[b, token, state, error]
parser[bool] parse parser[bool]
parser[char] ! (char -> bool) -> parser[char]
parser[char] ! char -> parser[char]
parser[char] parse parser[char]
parser[data1] parse1 parser[data1]
parser[data2] & parser[data1] ** (data1 -> parser[data2]) -> parser[data2]
parser[data2] & parser[data1] ** parser[void] ** (data1 -> parser[data2]) -> parser[data2]
parser[data2] ; parser[data1] ** (option[data1] -> parser[data2]) -> parser[data2]
parser[data2] ; parser[data1] ** parser[void] ** (option[data1] -> parser[data2]) -> parser[data2]
parser[data2] parse2 parser[data2]
parser[data] <| parser[void] ** parser[data] -> parser[data]
parser[data] <|> parser[data] ** parser[void] -> parser[data]
parser[data] parse parser[data] : [1], [2], [3]
parser[data] phantom parser[data] -> parser[data]
parser[data] |> parser[data] ** parser[void] -> parser[data]
parser[denotation] * (char -> bool) -> parser[denotation]
parser[denotation] + (char -> bool) -> parser[denotation]
parser[denotation] chunk nat -> parser[denotation]
parser[denotation] digits parser[denotation]
parser[denotation] letters parser[denotation]
parser[denotation] line parser[denotation]
parser[denotation] parse parser[denotation]
parser[denotation] upto (char -> bool) -> parser[denotation]
parser[denotation] upto char -> parser[denotation]
parser[int] parse parser[int]
parser[nat] parse parser[nat]
parser[option[data]] ? parser[data] -> parser[option[data]]
parser[pair[a, b], token, state, error] <> (() -> parser[a, token, state, error]) ** (() -> parser[b, token, state, error]) -> () -> parser[pair[a, b], token, state, error]
parser[real] parse parser[real]
parser[seq[data]] * parser[data] ** parser[void] -> parser[seq[data]]
parser[seq[data]] * parser[data] -> parser[seq[data]]
parser[seq[data]] + parser[data] ** parser[void] -> parser[seq[data]]
parser[seq[data]] + parser[data] -> parser[seq[data]]
parser[seq[data]] ++ parser[seq[data]] ** parser[seq[data]] -> parser[seq[data]]
parser[seq[data]] :: parser[data] ** parser[seq[data]] -> parser[seq[data]]
parser[seq[data]] <> parser[seq[data]]
parser[seq[data]] max nat ** parser[data] -> parser[seq[data]]
parser[seq[data]] min nat ** parser[data] -> parser[seq[data]]
parser[seq[data]] until parser[data] ** (string -> bool) -> parser[seq[data]]
parser[seq[data]] until parser[data] ** parser[void] -> parser[seq[data]]
parser[seq[data]] x nat ** nat ** parser[data] -> parser[seq[data]]
parser[seq[data]] x nat ** parser[data] -> parser[seq[data]]
parser[state, token, state, error] get () -> parser[state, token, state, error]
parser[string] * (char -> bool) -> parser[string]
parser[string] + (char -> bool) -> parser[string]
parser[string] chunk nat -> parser[string]
parser[string] digits parser[string]
parser[string] letters parser[string]
parser[string] line parser[string]
parser[string] parse parser[string]
parser[string] upto (char -> bool) -> parser[string]
parser[string] upto char -> parser[string]
parser[to] * (from -> to) ** parser[from] -> parser[to]
parser[token, token, state, error] shift () -> parser[token, token, state, error]
parser[token, token, state, error] shift (token -> bool) -> () -> parser[token, token, state, error]
parser[void, char, position, error] advanceCol () -> parser[void, char, position, error]
parser[void, char, position, error] advanceCol nat -> () -> parser[void, char, position, error]
parser[void, char, position, error] advanceRow () -> parser[void, char, position, error]
parser[void, char, position, error] advanceRow nat -> () -> parser[void, char, position, error]
parser[void, char, position, error] blank () -> parser[void, char, position, error]
parser[void, char, position, error] litChar char -> () -> parser[void, char, position, error]
parser[void, char, position, error] litString string -> () -> parser[void, char, position, error]
parser[void, char, position, error] newline () -> parser[void, char, position, error]
parser[void, char, position, error] tab () -> parser[void, char, position, error]
parser[void, token, state, error] eof () -> parser[void, token, state, error]
parser[void, token, state, error] peek (token -> bool) -> () -> parser[void, token, state, error]
parser[void, token, state, error] reject (() -> parser[a, token, state, error]) -> () -> parser[void, token, state, error]
parser[void, token, state, error] set state -> () -> parser[void, token, state, error]
parser[void, token, state, error] skip () -> parser[void, token, state, error]
parser[void, token, state, error] skip (token -> bool) -> () -> parser[void, token, state, error]
parser[void] ! denotation -> parser[void]
parser[void] $ parser[void]
parser[void] <> parser[void]
parser[void] clear parser[void]
parser[void] ignore parser[data] -> parser[void]
parser[void] insert string -> parser[void]
parser[void] skip parser[void]
parser[void] switch string -> parser[void]
parser[void] unget char -> parser[void]
parser[void] upd (string -> string) -> parser[void]
parser[void] ws parser[void]

next node: [ pe ] to [ re ],
prev node: [ mo ] to [ na ],
up to node: Function Index By Codomain