Module lazy

Procs

proc emptyIter*[T](): iterator (): T
emptyIter() ->
proc repeat*[T](value: T; n: int = - 1): iterator (): T
repeat(5) -> 5; 5; 5; 5; ...
repeat(5,n=2) -> 5; 5
proc count*[T](start: T): iterator (): T
count(x0) -> x0; x0 + 1; x0 + 2; ...
proc count*[T](start: T; till: T; step: T = 1; includeLast = false): iterator (): T
count(x0, x1) -> x0; x0 + 1; x0 + 2; ...; x1-1
proc cycle*[T](iter: iterator (): T): iterator (): T
cycle(a;b;c) -> a;b;c;a;b;c;a;...
proc cycle*[T](iter: iterator (): T; iter2: iterator (): T): iterator (): T
cycle(a;b;c,  d;e) -> a;b;c;d;e;a;b;...
proc cycle*[T](iter: iterator (): T; iter2: iterator (): T; 
               iter3: iterator (): T): iterator (): T
cycle(a;b;c,  d;e,  f;g) -> a;b;c;d;e;f;g;a;b;...
proc nop*[T](iter: iterator (): T): iterator (): T
nop(a;b;c;...) -> a;b;c;...
proc len*[T](iter: iterator (): T): int
len(a;b;c;d) -> 4
proc toSeq*[T](iter: iterator (): T; limit: int = - 1): seq[T]
toSeq(1;2;3) -> @[1,2,3]
proc reverse*[T](iter: iterator (): T): iterator (): T
reverse(1;2;3) -> 3;2;1
proc `$`*[T](iter: iterator (): T; limit = 10): string
$(1;2;3) -> "toIter(@[1, 2, 3])"
proc first*[T](iter: iterator (): T): T
first(a;b;c;d) -> a
proc first*[T](iter: iterator (): T; default: T): T
first(a;b;c;d) -> a
first(emptyIter(), default=99) -> 99
proc last*[T](iter: iterator (): T): T
last(a;b;c;d) -> d
proc last*[T](iter: iterator (): T; default: T): T
last(a;b;c;d) -> d
last(emptyIter(), default=99) -> 99
proc peek*[T](iter: iterator (): T): T
peek(a;b;c;d) -> a    (without removing)
proc peek*[T](iter: iterator (): T; default: T): T
peek(a;b;c;d) -> a    (without removing)
peek(emptyIter(), default=99) -> 99
proc peekList*[T](iter: iterator (): T; n: int): seq[T]
peekList(a;b;c;d, 2) -> @[a,b]    (without removing)
proc hasNext*[T](iter: var iterator (): T): bool
hasNext(a;b;c;d) -> true    (without removing)
hasNext(emptyIter())        -> false
proc print*[T](iter: iterator (): T; comment: string = ""): iterator (): T
print(a;b;c;d) -> a;b;c;d    (and also printing)
proc iterate*[T](f: proc (anything: T): T; x0: T): iterator (): T
iterate(f, x0) -> x0; f(x0); f(f(x0)); ...
proc take*[T](iter: iterator (): T; n: int): iterator (): T
take(1;2;3;4, 3) -> 1;2;3
take(1;2, 3) -> 1;2
proc takeWhile*[T](iter: iterator (): T; cond: proc (x: T): bool): iterator (): T
takeWhile(1;2;3;4, proc(x: int): bool = x < 4) -> 1;2;3
proc takeLast*[T](iter: iterator (): T; n: int = 1): iterator (): T
takeLast(1;2;3;4;5, 3) -> 3;4;5
takeLast(1;2, 3) -> 1;2
proc drop*[T](iter: iterator (): T; n: int = 1): iterator (): T
drop(1;2;3;4;5, 3) -> 4;5
drop(1;2, 3) -> 
proc dropWhile*[T](iter: iterator (): T; cond: proc (x: T): bool): iterator (): T
dropWhile(1;2;3;4, proc(x: int): bool = x < 4) -> 1;2;3
proc dropLast*[T](iter: iterator (): T; n: int = 1): iterator (): T
dropLast(1;2;3;4;5, 3) -> 1;2
dropLast(1;2, 3) -> 
proc toTable*[A, B](iter: iterator (): (A, B)): Table[A, B]
toTable((1,"A");(2,"B");(3,"C")) -> {1: "A", 2: "B", 3: "C"}
proc toTable*[A, B](iter: iterator (): (A, B); aggr: proc (any1, any2: B): B): Table[
    A, B]
toTable((1,"A");(2,"B");(3,"C"), (x, y:string) => x&","&y)
                           -> {1: "A", 2: "B", 3: "C"}
proc toTableSeq*[A, B](iter: iterator (): (A, B)): Table[A, seq[B]]
toTableSeq((1,"A");(1,"B");(3,"C")) -> {1: ["A", "B"], 3: ["C"]}
proc toIter*[T](s: openArray[T]): iterator (): T
toIter([1,2,3]) -> 1;2;3
proc toIter*[T](s: seq[T]): iterator (): T
toIter(@[1,2,3]) -> 1;2;3
proc toIter*[A, B](t: Table[A, B]): (iterator (): (A, B))
toIter({1:"A", 2:"B"}) -> (1,"A");(2,"B")
proc filter*[T](iter: iterator (): T; f: (proc (any: T): bool)): iterator (): T
filter(1;2;3;4;5, proc(x: int): bool = x>3) -> 4;5
proc map*[T, S](iter: iterator (): T; f: (proc (any: T): S)): iterator (): S
map(1;2;3;4;5, f) -> f(1);f(2);f(3);f(4);f(5)
proc map*[T, S, U](iter: iterator (): T; f: (proc (anyT: T; anyU: U): S); 
                   iter2: iterator (): U): iterator (): S
map(1;2;3;4;5, f, 10;20;30) -> f(1,10);f(2,20);f(3,30)
proc map*[T, S, U, V](iter: iterator (): T; 
                      f: (proc (anyT: T; anyU: U; anyV: V): S); 
                      iter2: iterator (): U; iter3: iterator (): V): iterator (): S
Map for 3 parameters 
proc replace*[T](iter: iterator (): T; n: int; value: T): iterator (): T
replace(1;2;3;4;5, 3, 100) -> 1;2;3;100;5
proc replace*[T](iter: iterator (): T; f: proc (x: T): bool; value: T): iterator (): T
replace(1;2;3;4;5, f, 100) -> 1;2;3;100;5  (if f(4) is the only true)
proc replace*[T](iter: iterator (): T; f: proc (x: T): bool; 
                 valueF: proc (x: T): T): iterator (): T
replace(1;2;3;4;5, f, g) -> 1;2;3;g(4);5  (if f(4) is the only true)
proc flatten*[T](iter: iterator (): iterator (): T): iterator (): T
flatten((1;2;3);(10;11;12)) -> 1;2;3;10;11;12
proc concat*[T](iter: iterator (): T; iter2: iterator (): T): iterator (): T
concat(1;2;3), (10;11;12) -> 1;2;3;10;11;12
proc unique*[T](iter: iterator (): T): iterator (): T
unique(1;2;4;3;2;6;5) -> 1;2;4;3;6;5
proc unique*[T, S](iter: iterator (): T; f: proc (any: T): S): iterator (): T
unique(1;2;4;3;2;6;5, proc(x: int):int = x div 5) -> 1;6
proc copy*[T](iter: iterator (): T): iterator (): T
copy(1;2;3;4;5) -> 1;2;3;4;5     (keeps original as well)
proc `[]`*[T](iter: iterator (): T; n: int): T
(1;2;3;4;5)[1] -> 2
proc `[]=`*[T](iter: var iterator (): T; n: int; value: T)
(1;2;3;4;5)[1] = 100 ->
           (the original is modified to 1;100;3;4;5)
proc `[]=`*[T](iter: var iterator (): T; selector: iterator (): bool; value: T)
(1;2;3;4;5)[false;false;true;false;false] = 100 ->
                    (the original is modified to 1;2;100;4;5)
proc fold*[T](iter: iterator (): T; f: proc (a, b: T): T): T
fold(1;2;3, proc(a,b: int): int=a+b) -> 6
proc fold*[T](iter: iterator (): T; f: proc (a, b: T): T; start: T): T
fold(1;2;3, proc(a,b: int): int=a+b, 100) -> 106
proc foldList*[T](iter: iterator (): T; f: proc (a, b: T): T): iterator (): T
foldList(1;2;3, proc(a,b: int): int=a+b) -> 1;3;6
proc partitionSeq*[T](iter: iterator (): T; n: int): iterator (): seq[T]
partitionSeq(1;2;3;4;5;6,7, 2) -> @[1,2];@[3,4];@[5,6]
proc partitionSeq*[T](iter: iterator (): T; n, step: int): iterator (): seq[T]
partitionSeq(1;2;3;4;5, 2,1) -> @[1,2];@[2,3];@[3,4];@[4,5]
proc partitionSeq*[T](iter: iterator (): T; n, step: int; pad: T): iterator (): seq[
    T]
partitionSeq(1;2;3;4;5, 2,2,99) -> @[1,2];@[3,4];@[5,99]
proc partitionBy*[T, S](iter: iterator (): T; f: proc (any: T): S): iterator (): (
    S, seq[T])
partitionBy(1;2;3;4;5, proc(x: int): bool = x mod 3==0) ->
                         @[1,2];@[3];@[4,5]

Iterators

iterator items*[T](iter: iterator (): T): T
items(a;b;c;...) -> yield a; yield b; yield c; ...

Templates

template yieldAll*[T](iter: iterator (): T)
yieldAll(iter) -> for x in iter(): yield
template iterateP*[T](params, f: expr; x0: T): iterator (): T
iterateP(a, a+10, x0) -> x0; x0+10; x0+10+10; ...
template iterateIt*[T](f: expr; x0: T): (iterator (): T) {.immediate.}
iterateIt(it*2, x0) -> x0; x0*2; x0*2*2; ...
template iterateKV*[T, S](f: expr; x0: (T, S)): (iterator (): (T, S)) {.
    immediate.}
iterateKV((2*k, 3*v), (1,1)) -> (1,1); (2,3); (4,9); ...
template takeWhileP*[T](iter: iterator (): T; params, cond: expr): iterator (): T
takeWhile(1;2;3;4, Q, Q < 4) -> 1;2;3
template takeWhileIt*[T](iter: iterator (): T; cond: expr): iterator (): T
takeWhileIt(1;2;3;4, it < 4) -> 1;2;3
template takeWhileKV*[T](iter: iterator (): T; cond: expr): iterator (): T
takeWhileKV((1,2);(1,3);(10;4), k == 1) -> (1,2);(1;3)
template dropWhileP*[T](iter: iterator (): T; params, cond: expr): iterator (): T
dropWhileP(1;2;3;4, Q, Q < 4) -> 1;2;3
template dropWhileIt*[T](iter: iterator (): T; cond: expr): iterator (): T
dropWhileIt(1;2;3;4, proc(x: int): bool = x < 4) -> 1;2;3
template dropWhileKV*[T](iter: iterator (): T; cond: expr): iterator (): T
dropWhileKV((1,2);(1,3);(10,4), v == 2) -> (1,3);(10,4)
template toTableP*[A, B](iter: iterator (): (A, B); params, f: expr): Table[A, B]
toTableP((1,"A");(1,"B");(3,"C"), (A,B), A&B) -> {1: "AB", 3: "C"}
template toTableAB*[A, B](iter: iterator (): (A, B); f: expr): Table[A, B]
toTableP((1,"A");(1,"B");(3,"C"), a&b) -> {1: "AB", 3: "C"}
template filterP*[T](iter: iterator (): T; params, f: expr): iterator (): T
filter(1;2;3;4;5, Q, Q>3) -> 4;5
template filterIt*[T](iter: iterator (): T; f: expr): iterator (): T
filterIt(1;2;3;4;5, it>3) -> 4;5
template filterKV*[A, B](iter: iterator (): (A, B); f: expr): iterator (): (A, B)
filterKV(("one", 1);("two", 2);("three", 3), v>1)
                                 -> ("two", 2);("three", 3)
template mapP*[T, S](iter: iterator (): T; params, f: expr): iterator (): S
mapP(1;2;3;4;5, Q, Q+10) -> 11;12;13;14;15
template mapIt*[T, S](iter: iterator (): T; f: expr): iterator (): S
mapIt(1;2;3;4;5, it+10) -> 11;12;13;14;15
template mapKV*[A, B, T](iter: iterator (): (A, B); f: expr): iterator (): T
mapKV(("one", 1);("two", 2);("three", 3), v) -> 1;2;3
template mapP*[T, S, U](iter: iterator (): T; params, f: expr; 
                        iter2: iterator (): U): iterator (): S
map(1;2;3;4;5, (P,Q), P+Q, 10;20;30) -> 11,22,33
template mapIt*[T, S, U](iter: iterator (): T; f: expr; iter2: iterator (): U): iterator (): S
map(1;2;3;4;5, it+it2, 10;20;30) -> 11,22,33
template mapKV*[A, B, C, D, T](iter: iterator (): (A, B); f: expr; 
                               iter2: iterator (): (C, D)): iterator (): T
map((1,a);(2,b), (k,v2), (10,A);(20,B)) -> (1,A);(2,B)
template mapP*[T, S, U, V](iter: iterator (): T; params, f: expr; 
                           iter2: iterator (): U; iter3: iterator (): V): iterator (): S
Map for 3 parameters 
template mapIt*[T, S, U, V](iter: iterator (): T; f: expr; 
                            iter2: iterator (): U; iter3: iterator (): V): iterator (): S
Map for 3 parameters 
template mapKV*[A, B, C, D, E, F, T](iter: iterator (): (A, B); f: expr; 
                                     iter2: iterator (): (C, D); 
                                     iter3: iterator (): (E, F)): iterator (): T
Map for 3 parameters 
template replaceP*[T](iter: iterator (): T; params, f: expr; value: T): iterator (): T
replace(1;2;3;4;5, Q, Q==4, 100) -> 1;2;3;100;5
template replacePV*[T](iter: iterator (): T; params, f: expr; valueF: expr): iterator (): T
replace(1;2;3;4;5, Q, Q==4, Q+100) -> 1;2;3;104;5
template replaceIt*[T](iter: iterator (): T; f: expr; value: expr): iterator (): T
replaceIt(1;2;3;4;5, it>2, 200) -> 1;2;200;200;200
template replaceKV*[A, B](iter: iterator (): (A, B); f: expr; valueF: expr): iterator (): (
    A, B)
replaceKV(("one", 1);("two", 2);("three", 3), k=="one", (k, 100)) ->
                            ("one", 100);("two", 2);("three", 3)
template uniqueP*[T](iter: iterator (): T; params, f: expr): iterator (): T
unique(1;2;4;3;2;6;5, Q, Q div 5) -> 1;6
template uniqueIt*[T](iter: iterator (): T; f: expr): iterator (): T
unique(1;2;4;3;2;6;5, it div 5) -> 1;6
template uniqueKV*[T](iter: iterator (): T; f: expr): iterator (): T
unique((1,A);(2,B);(3,B), v) -> (1,A);(2;B)
template foldP*[T](iter: iterator (): T; params, f: expr): T
foldP(1;2;3, (P,Q), P+Q) -> 6
template foldP*[T](iter: iterator (): T; params, f: expr; start: T): T
foldP(1;2;3, (P,Q), P+Q, 100) -> 106
template foldAB*[T](iter: iterator (): T; f: expr): T
foldAB(1;2;3, a+b) -> 6
template foldAB*[T](iter: iterator (): T; f: expr; start: T): T
foldAB(1;2;3, a+b, 100) -> 106
template foldListP*[T](iter: iterator (): T; params, f: expr): iterator (): T
foldListP(1;2;3, (P,Q), P+Q) -> 1;3;6
template foldListAB*[T](iter: iterator (): T; f: expr): T
foldListAB(1;2;3, a+b) -> 1;3;6
template partition*[T](iter: iterator (): T; n: int): iterator (): expr
partition(1;2;3;4;5;6,7, 2) -> (1,2);(3,4);(5,6)
template partition*[T](iter: iterator (): T; n, step: int): iterator (): expr
partition(1;2;3;4;5, 2,1) -> (1,2);(2,3);(3,4);(4,5)
template partition*[T](iter: iterator (): T; n, step: int; pad: T): iterator (): expr
partition(1;2;3;4;5, 2,2,99) -> (1,2);(3,4);(5,99)
template partitionByP*[T, S](iter: iterator (): T; params, f: expr): iterator (): (
    S, seq[T])
partitionByP(1;2;3;4;5, P, P mod 3==0) ->
                         @[1,2];@[3];@[4,5]
template partitionByIt*[T, S](iter: iterator (): T; f: expr): iterator (): (S, 
    seq[T])
partitionByIt(1;2;3;4;5, it mod 3==0) ->
                         @[1,2];@[3];@[4,5]
template partitionByKV*[T, S](iter: iterator (): T; f: expr): iterator (): (S, 
    seq[T])
partitionByKV((1,a);(2,a);(3,b);(4,b);(5,c), v) ->
                         @[(1,a),(2,a)];@[(3,b),(4,b)];@[(5,c)]
template wrapIter*[T](iter: expr): iterator (): T
wrapIter(walkFiles("*")) -> "a.nim"; "b.nim"; ...
template createIterFor2Params*(name: expr): stmt
Creates public functions from functions with 2 parameters. The resulting functions can take an interator in its first or second parameter, or both
createIterFor2Params `+`
(1;2;3;4) + (10;20;30) -> 11;22;33
template createIterFor1Param*(name: expr): stmt
Creates public functions from functions with 1 parameter. The resulting functions can take an interator in its first parameter.
createIterFor1Param `not`
not (false;false;true) -> true;true;false

Made with Nim. Generated: 2015-05-31 16:06:03 UTC