Index

Modules: slicerator, slicerator/chainimpl, slicerator/closures, slicerator/itermacros.

API symbols

`[]`:

• slicerator: iterator `[]`[T](a: openArray[T]; slice: HSlice[int, BackwardsIndex]): T
• slicerator: iterator `[]`[T](a: openArray[T]; slice: Slice[int]): T

`{}`:

• slicerator: iterator `{}`[T](a: var openArray[T]; slice: HSlice[int, BackwardsIndex]): var T
• slicerator: iterator `{}`[T](a: var openArray[T]; slice: Slice[int]): var T

all:

• itermacros: template all[T](iter: iterable[T]; pred: proc (x: T): bool): bool

allIt:

• itermacros: template allIt[T](iter: iterable[T]; expr: untyped): bool

any:

• itermacros: template any[T](iter: iterable[T]; pred: proc (x: T): bool): bool

anyIt:

• itermacros: template anyIt[T](iter: iterable[T]; expr: untyped): bool

asClosure:

• closures: macro asClosure(iter: iterable): untyped

chain:

• chainimpl: macro chain(forloop: ForLoopStmt): untyped

colChain:

• chainimpl: macro colChain(forloop: ForLoopStmt): untyped

collect:

• closures: proc collect[T](iter: Iterator[T]): seq[T]
• itermacros: template collect[T](iter: iterable[T]; size: Natural = 1): seq[T]
• itermacros: template collect[T, U](iter: iterable[T]; t: typedesc[U]): U

Comparable:

• itermacros: type Comparable

count:

• itermacros: template count[T](iter: iterable[T]): Natural

enumerate:

• itermacros: template enumerate[T](iter: iterable[T]): untyped

filter:

• slicerator: macro filter(forLoop: ForLoopStmt): untyped
• closures: proc filter[T](iter: Iterator[T]; cond: proc (a: T): bool): iterator (): T
• itermacros: template filter[T](iter: iterable[T]; pred: proc (x: T): bool): untyped

filterIt:

• itermacros: template filterIt[T](iter: iterable[T]; expr: untyped): untyped

find:

• itermacros: template find[T](iter: iterable[T]; pred: proc (x: T): bool): Option[T]

findAll:

• slicerator: iterator findAll[T](a: openArray[T]; val: T): int

findIt:

• itermacros: template findIt[T](iter: iterable[T]; expr: untyped): Option[T]

flatten:

• itermacros: template flatten[T](iter: iterable[T]): untyped

fold:

• itermacros: template fold[T, U](iter: iterable[T]; init: U; fn: proc (acc: sink U; it: T): U): U
• itermacros: template fold[T, U](iter: iterable[T]; init: U; fn: proc (acc: var U; it: T)): U

foldIt:

• itermacros: template foldIt[T, U](iter: iterable[T]; init: U; expr: untyped): U

forMItems:

• slicerator: template forMItems[T](a: var openArray[T]; indexName, valName, body: untyped): untyped

genIter:

• itermacros: macro genIter[T](iter: iterable[T]; body: varargs[untyped]): untyped

group:

• closures: proc group[T](iter: Iterator[T]; count: static int): iterator (): (int, array[count, T])
• itermacros: template group[T](iter: iterable[T]; amount: static Positive): untyped

groups:

• slicerator: macro groups(body: ForLoopStmt): untyped

iterRange:

• slicerator: template iterRange(iter, val: untyped; rng: Slice[int]; body: untyped)

iterThenReset:

• closures: iterator iterThenReset[T](clos: var iterator (): T): T
• closures: iterator iterThenReset[T](clos: var iterator (): lent T): T

map:

• slicerator: macro map(forLoop: ForLoopStmt): untyped
• slicerator: template map[T; Y](i: iterable[T]; p: proc (x: T): Y): untyped
• closures: proc map[T, Y](iter: Iterator[T]; mapProc: proc (a: T): Y): iterator (): Y
• itermacros: template map[T; Y](iter: iterable[T]; fn: proc (x: T): Y): untyped
• itermacros: template map[T; Y](iter: iterable[T]; fn: proc (x: T): Y {.inline.}): untyped

mapIt:

• itermacros: template mapIt[T](iter: iterable[T]; expr: untyped): untyped

max:

• itermacros: template max[T: Comparable](iter: iterable[T]): T

mFindAll:

• slicerator: iterator mFindAll[T](a: var openArray[T]; val: T): var T

min:

• itermacros: template min[T: Comparable](iter: iterable[T]): T

Multipliable:

• itermacros: type Multipliable

nth:

• itermacros: template nth[T](iter: iterable[T]; n: Natural): Option[T]

pairs:

• slicerator: iterator pairs[T](a: openArray[T]; slice: HSlice[int, BackwardsIndex]): (int, T)
• slicerator: iterator pairs[T](a: openArray[T]; slice: HSlice[int, int]): (int, T)

peek:

• closures: proc peek[T](clos: var Iterator[T]): T

position:

• itermacros: template position[T](iter: iterable[T]; pred: proc (x: T): bool): Option[int]

positionIt:

• itermacros: template positionIt[T](iter: iterable[T]; expr: untyped): Option[int]

product:

• itermacros: template product[T: Multipliable](iter: iterable[T]): T

reset:

• closures: proc reset[T](clos: var Iterator[T])

revItems:

• slicerator: iterator revItems[T](a: openArray[T]): T

revMitems:

• slicerator: iterator revMitems[T](a: var openArray[T]): var T

rFindAll:

• slicerator: iterator rFindAll[T](a: openArray[T]; val: T): int

rMFindAll:

• slicerator: iterator rMFindAll[T](a: var openArray[T]; val: T): var T

skip:

• itermacros: template skip[T](iter: iterable[T]; amount: Natural): untyped

skipIter:

• slicerator: template skipIter(iter, val: untyped; toSkip: Natural; body: untyped)

skipWhile:

• itermacros: template skipWhile[T](iter: iterable[T]; pred: proc (x: T): bool): untyped

skipWhileIt:

• itermacros: template skipWhileIt[T](iter: iterable[T]; expr: untyped): untyped

splitOn:

• itermacros: template splitOn[Y, T](iter: iterable[Y]; theSplit: T): untyped

splitOnContainer:

• itermacros: template splitOnContainer[Y, T](iter: iterable[Y]; theSplit: T): untyped

stepBy:

• itermacros: template stepBy[T](iter: iterable[T]; step: Positive): untyped

sum:

• itermacros: template sum[T: Summable](iter: iterable[T]): T

Summable:

• itermacros: type Summable

take:

• itermacros: template take[T](iter: iterable[T]; amount: Natural): untyped

takeWhile:

• itermacros: template takeWhile[T](iter: iterable[T]; pred: proc (x: T): bool): untyped

takeWhileIt:

• itermacros: template takeWhileIt[T](iter: iterable[T]; expr: untyped): untyped

zip:

• slicerator: macro zip(others: varargs[untyped]): untyped

zipIter:

• slicerator: macro zipIter(forBody: ForLoopStmt): untyped