Index

Modules: funcynim/call, funcynim/chain, funcynim/convert, funcynim/default, funcynim/ifelse, funcynim/ignore, funcynim/lambda, funcynim/nimnodes, funcynim/operators, funcynim/partialproc, funcynim/proctypes, funcynim/unit.

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: untyped; remaining: varargs[untyped]): 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

convert:

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

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

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)

isUnderscore:

• partialproc: isUnderscore(n: NimNode): bool

lambda:

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

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

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

resultType:

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

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