next node: [ pe ] to [ pr ],
prev node: [ me ] to [ na ],
up to node: Function Index By Domain

Function Index By Domain [ op ] to [ pa ]

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

op

option avail? option -> bool
option cont option -> data
option nil? option -> bool
option[arg] * (arg -> res) ** option[arg] -> option[res]
option[data1] ; parser[data1] ** (option[data1] -> parser[data2]) -> parser[data2]
option[data1] ; parser[data1] ** parser[void] ** (option[data1] -> parser[data2]) -> parser[data2]
option[data] asParser (string -> option[data] ** string) -> parser
option[data] iter (data -> option[data] ** option[data]) ** option[data] -> bstree
option[data] iter (data -> option[data] ** option[data]) ** option[data] -> heap
option[data] iter (data -> option[data] ** option[data]) ** option[data] -> tree
option[denotation] createApp interpreter[state] ** option[denotation] ** denotation -> com[void]
option[seq[string]] execve denotation ** seq[string] ** option[seq[string]] -> com[void]

or

orient horizontal? orient -> bool
orient orient orient -> config
orient scroll scroller ** orient -> config
orient vertical? orient -> bool

ou

outData write channel ** outData -> com[void]
output close output -> com[void]
output rep output -> file
output write output ** char -> com[void]
output write output ** denotation ** data -> com[void]
output write output ** denotation -> com[void]
output write output ** string -> com[void]
output writeLine output ** denotation -> com[void]
output writeLine output ** string -> com[void]
output writeLines output ** seq[string] -> com[void]

pa

packOp < packOp ** packOp -> bool
packOp = packOp ** packOp -> bool
pair &? pair -> bool
pair 1st pair -> data1
pair 2nd pair -> data2
pair unpair pair -> data1 ** data2
pair[data1, data2] * (data1 -> data11) ** (data2 -> data21) ** pair[data1, data2] -> pair[data11, data21]
pair[data1, data2] < pair[data1, data2] ** pair[data1, data2] -> bool : [1], [2]
pair[dom, codom] less pair[dom, codom] ** pair[dom, codom] -> bool : [1], [2], [3]
parser @ parser ** string -> option[data]
parser @! parser ** string -> data
parser asFct parser -> string -> option[data] ** string
parser asParser? parser -> bool
parser parser parser -> seq[token] ** state -> either[option[error], a] ** seq[token] ** state
parser parser? parser -> bool
parser run seq[token] ** state ** (() -> parser) -> either[option[error], a]
parser | parser ** parser -> parser
parser[a, token, state, error] & (() -> parser[a, token, state, error]) ** (a -> () -> parser[b, token, state, error]) -> () -> parser[b, token, state, error]
parser[a, token, state, error] * (() -> parser[a, token, state, error]) ** (a -> b) -> () -> parser[b, token, state, error]
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[b, token, state, error]) -> () -> parser[pair[a, b], token, state, error]
parser[a, token, state, error] >> (() -> parser[a, token, state, error]) ** (() -> parser[b, token, state, error]) -> () -> parser[b, token, state, error]
parser[a, token, state, error] reject (() -> parser[a, token, state, error]) -> () -> parser[void, 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]) ** (() -> parser[b, token, state, error]) -> () -> parser[a, token, state, error]
parser[b, token, state, error] <> (() -> parser[a, token, state, error]) ** (() -> parser[b, token, state, error]) -> () -> parser[pair[a, 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[data1] & parser[data1] ** (data1 -> parser[data2]) -> parser[data2]
parser[data1] & parser[data1] ** parser[void] ** (data1 -> parser[data2]) -> parser[data2]
parser[data1] ; parser[data1] ** (option[data1] -> parser[data2]) -> parser[data2]
parser[data1] ; parser[data1] ** parser[void] ** (option[data1] -> parser[data2]) -> parser[data2]
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[data] * parser[data] ** parser[void] -> parser[seq[data]]
parser[data] * parser[data] -> parser[seq[data]]
parser[data] + parser[data] ** parser[void] -> parser[seq[data]]
parser[data] + parser[data] -> parser[seq[data]]
parser[data] :: parser[data] ** parser[seq[data]] -> parser[seq[data]]
parser[data] <| parser[void] ** parser[data] -> parser[data]
parser[data] <|> parser[data] ** parser[void] -> parser[data]
parser[data] ? parser[data] -> parser[option[data]]
parser[data] ignore parser[data] -> parser[void]
parser[data] max nat ** parser[data] -> parser[seq[data]]
parser[data] min nat ** parser[data] -> parser[seq[data]]
parser[data] phantom parser[data] -> parser[data]
parser[data] until parser[data] ** (string -> bool) -> parser[seq[data]]
parser[data] until parser[data] ** parser[void] -> parser[seq[data]]
parser[data] x nat ** nat ** parser[data] -> parser[seq[data]]
parser[data] x nat ** parser[data] -> parser[seq[data]]
parser[data] |> parser[data] ** parser[void] -> parser[data]
parser[from] * (from -> to) ** parser[from] -> parser[to]
parser[seq[data]] ++ parser[seq[data]] ** parser[seq[data]] -> parser[seq[data]]
parser[seq[data]] :: parser[data] ** parser[seq[data]] -> parser[seq[data]]
parser[void] & parser[data1] ** parser[void] ** (data1 -> parser[data2]) -> parser[data2]
parser[void] * parser[data] ** parser[void] -> parser[seq[data]]
parser[void] + parser[data] ** parser[void] -> parser[seq[data]]
parser[void] ; parser[data1] ** parser[void] ** (option[data1] -> parser[data2]) -> parser[data2]
parser[void] <| parser[void] ** parser[data] -> parser[data]
parser[void] <|> parser[data] ** parser[void] -> parser[data]
parser[void] until parser[data] ** parser[void] -> parser[seq[data]]
parser[void] |> parser[data] ** parser[void] -> parser[data]

next node: [ pe ] to [ pr ],
prev node: [ me ] to [ na ],
up to node: Function Index By Domain