Index

Modules: funcynim/call, funcynim/chain, funcynim/convert, funcynim/curry, funcynim/default, funcynim/fold, funcynim/ifelse, funcynim/ignore, funcynim/into, funcynim/itself, funcynim/lambda, funcynim/nimnodes, funcynim/operators, funcynim/partialproc, funcynim/proctypes, funcynim/run, funcynim/unit, funcynim/variables.

API symbols

call:

• call: call[T](p: proc (): T {.nimcall.}): T
• call: call[T](p: proc (): T {.closure.}): T
• call: call(p: proc () {.nimcall.})
• call: call(p: proc () {.closure.})
• call: call(p: proc; arg1: typed; remaining: varargs[typed]): untyped

chain:

• chain: chain[A; B; C](f: A -> B; g: B -> C): A -> C
• chain: chain[A; B](f: () -> A; g: A -> B): () -> B

compose:

• chain: compose[A; B; C](self: B -> C; prev: A -> B): A -> C

convert:

• convert: convert[A; B](a: A): B
• convert: convert[A](a: A; B: typedesc): B:type

curry:

• curry: curry(self: untyped{nkProcDef | nkFuncDef}): auto
• curry: curry(self: untyped{nkLambda}): auto

default:

• default: default[T](): T
• unit: default(T: typedesc[Unit]): Unit

divFloat:

• operators: divFloat[T: SomeFloat](x, y: T): T

divInt:

• operators: divInt[T: SomeInteger](x, y: T): T

doNothing:

• unit: doNothing[T](_: T): Unit

equal:

• operators: equal[T](x, y: T): bool

firstChild:

• nimnodes: firstChild(self: NimNode): NimNode

fold:

• fold: fold[T](self: bool; then, else: Unit -> T): T

greater:

• operators: greater[T](x, y: T): bool

greaterOrEq:

• operators: greaterOrEq[T](x, y: T): bool

high:

• nimnodes: high(self: NimNode): NimNodeIndex

ifElse:

• ifelse: ifElse[T](condition: bool; then, else: () -> T): T

ignore:

• ignore: ignore[T](_: T)

into:

• into: into[A; B](self: A; f: A -> B): B

isUnderscore:

• partialproc: isUnderscore(n: NimNode): bool

itself:

• itself: itself[T](self: T): T

lambda:

• lambda: lambda[T](expr: T): auto

less:

• operators: less[T](x, y: T): bool

lessOrEq:

• operators: lessOrEq[T](x, y: T): bool

logicAnd:

• operators: logicAnd(x, y: bool): bool

logicNot:

• operators: logicNot(x: bool): bool

logicOr:

• operators: logicOr(x, y: bool): bool

low:

• nimnodes: low(self: NimNode): NimNodeIndex

minus:

• operators: minus[T](x, y: T): T

modify:

• variables: modify[T](self: var T; f: T -> T): var T
• variables: modify[T](self: var T; f: var T -> Unit): var T

modulo:

• operators: modulo[T: SomeInteger](x, y: T): T

mult:

• operators: mult[T](x, y: T): T

newLambda:

• partialproc: newLambda(params: seq[NimNode]; body: NimNode; returnType: NimNode): NimNode

next:

• operators: next[T: Ordinal](x: T): T

NimNodeIndex:

• nimnodes: NimNodeIndex

paramType:

• proctypes: paramType(T: typedesc[proc]; position: static Natural): typedesc
• proctypes: paramType(p: proc; position: static Natural): typedesc

partial:

• partialproc: partial(call: untyped{call}): untyped

partialParamPrefix:

• partialproc: partialParamPrefix(): string

partialTypedParamPrefix:

• partialproc: partialTypedParamPrefix(): string

plus:

• operators: plus[T](x, y: T): T

plus1:

• operators: plus1[T](x: T): T

prev:

• operators: prev[T: Ordinal](x: T): T

read:

• variables: read[T](self: var T): T

resultType:

• proctypes: resultType(T: typedesc[proc]): typedesc
• proctypes: resultType(p: proc): typedesc

run:

• run: run[T](self: Unit -> T): T
• run: run[A; B](self: A -> B; arg: A): B
• run: run[T](self: () -> T): T

secondChild:

• nimnodes: secondChild(self: NimNode): NimNode

to:

• convert: to[A; B](a: A): B
• convert: to[A](a: A; B: typedesc): B:type

Unit:

• unit: Unit

unit:

• unit: unit(): Unit

with:

• curry: with[A; B; C](curried: A -> (B -> C); arg: A): B -> C

write:

• variables: write[T](self: var T; value: T): var T