Index

Modules: bitwiseCopy, expandFirst, namedWhile, reinterpretPtr, replaceNimNodeTree, setLambda, staticDeque, staticSeq, unpackToArgs, withAliases.

API symbols

`==`:

• staticSeq: proc `==`[N: static int](x: StaticSeq; y: array[N, x.T]): bool

`[]=`:

• staticSeq: proc `[]=`(x: var StaticSeq; i: Natural; val: sink x.T)

`[]`:

• staticDeque: proc `[]`(x: StaticDeque; i: Natural): lent x.T
• staticDeque: proc `[]`(x: var StaticDeque; i: Natural): var x.T
• staticSeq: proc `[]`(x: StaticSeq; i: Natural): lent x.T
• staticSeq: proc `[]`(x: var StaticSeq; i: Natural): var x.T

`{}=`:

• staticSeq: proc `{}=`(x: var StaticSeq; i: Natural; val: sink x.T)

add:

• staticSeq: proc add(x: var StaticSeq; item: sink x.T)

addLast:

• staticDeque: proc addLast(x: var StaticDeque; item: sink x.T)

bitwiseCast:

• bitwiseCopy: proc bitwiseCast[T](source: auto): T

bitwiseCopy:

• bitwiseCopy: proc bitwiseCopy[T, U](dest: var T; source: U)

clear:

• staticSeq: proc clear(x: var StaticSeq)

doWithAliases:

• withAliases: template doWithAliases(args: varargs[untyped]): untyped

expandFirst:

• expandFirst: template expandFirst(macroOrTemplateCall, body: untyped): untyped

high:

• staticDeque: proc high(x: StaticDeque): int
• staticSeq: proc high(x: StaticSeq): int

isFull:

• staticDeque: proc isFull(x: StaticDeque): bool
• staticSeq: proc isFull(x: StaticSeq): bool

items:

• staticDeque: iterator items(x: StaticDeque): x.T
• staticSeq: iterator items(x: StaticSeq): lent x.T

len:

• staticDeque: proc len(x: StaticDeque): int
• staticSeq: proc len(x: StaticSeq): int

maxLen:

• staticDeque: proc maxLen(T: typedesc[StaticDeque]): int
• staticDeque: template maxLen(x: StaticDeque): int

minimumSizeInt:

• staticSeq: template minimumSizeInt(N: static range[1 .. int.high]): untyped

mitems:

• staticDeque: iterator mitems(x: var StaticDeque): var x.T
• staticSeq: iterator mitems(x: var StaticSeq): var x.T

namedWhile:

• namedWhile: macro namedWhile(expr, outerName, innerName, body: untyped): untyped

popFirst:

• staticDeque: proc popFirst(x: var StaticDeque): x.T

reinterpretPtr:

• reinterpretPtr: proc reinterpretPtr[T: ptr or cstring](src: ptr or pointer): T

replace:

• replaceNimNodeTree: proc replace(node, target, dest: NimNode): NimNode

setLambda:

• setLambda: macro setLambda(procVar: var proc; body: untyped): untyped

setLen:

• staticSeq: proc setLen(x: var StaticSeq; newLen: Natural)

StaticDeque:

• staticDeque: object StaticDeque

StaticSeq:

• staticSeq: object StaticSeq

toOpenArray:

• staticSeq: template toOpenArray(x: StaticSeq; first: Natural = 0): untyped
• staticSeq: template toOpenArray(x: StaticSeq; first, last: Natural): untyped

toStaticSeq:

• staticSeq: proc toStaticSeq[N: static Natural; T](src: static array[N, T]): StaticSeq[N, T]
• staticSeq: proc toStaticSeq(src: static string): auto

unpackToArgs:

• unpackToArgs: macro unpackToArgs(args: varargs[untyped]): untyped

waCompileTime:

• withAliases: WithAliasesFlag.waCompileTime

waSideEffect:

• withAliases: WithAliasesFlag.waSideEffect

withAliases:

• withAliases: macro withAliases(flags: static[set[WithAliasesFlag]]; args: varargs[untyped]): untyped

WithAliasesFlag:

• withAliases: enum WithAliasesFlag