Index

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

API symbols

`and`:

• predicate: `and`[T](left, right: Predicate[T]): Predicate[T]

`not`:

• predicate: `not`[T](self: Predicate[T]): Predicate[T]

`or`:

• predicate: `or`[T](left, right: Predicate[T]): Predicate[T]

alwaysFalse:

• predicate: alwaysFalse[T](_: T): bool

alwaysTrue:

• predicate: alwaysTrue[T](_: T): bool

chain:

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

combine:

• predicate: combine[T](left: Predicate[T]; right: Predicate[T]; combiner: (right: bool) -> ((left: bool) -> bool)): Predicate[T]
• predicate: combine[T](left: Predicate[T]; right: Predicate[T]; combiner: (left: bool, right: bool) -> bool): Predicate[T]

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
• predicate: fold[A; B](self: Predicate[A]; then, else: A -> B): A -> B

greater:

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

greaterOrEq:

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

high:

• nimnodes: high(self: NimNode): NimNodeIndex

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

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

Predicate:

• predicate: Predicate

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

test:

• predicate: test[T](self: Predicate[T]; value: T): bool

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