Iter[A: A]
Wrapper class containing methods to modify iterators.
class ref Iter[A: A] is
Iterator[A] ref
Implements
- Iterator[A] ref
Constructors
create
new ref create(
iter: Iterator[A] ref)
: Iter[A] ref^
Parameters
- iter: Iterator[A] ref
Returns
- Iter[A] ref^
maybe
new ref maybe(
value: (A | None val))
: Iter[A] ref^
Parameters
- value: (A | None val)
Returns
- Iter[A] ref^
chain
Take an iterator of iterators and return an Iter containing the items of the first one, then the second one, and so on.
Example
let xs = [as I64: 1; 2].values()
let ys = [as I64: 3; 4].values()
Iter[I64].chain([xs; ys].values())
1 2 3 4
new ref chain(
outer_iterator: Iterator[Iterator[A] ref] ref)
: Iter[A] ref^
Parameters
Returns
- Iter[A] ref^
repeat_value
Create an iterator that returns the given value forever.
Example
Iter[U32].repeat_value(7)
7 7 7 7 7 7 7 7 7 ...
new ref repeat_value(
value: A)
: Iter[A] ref^
Parameters
- value: A
Returns
- Iter[A] ref^
Public Functions
has_next
fun ref has_next()
: Bool val
Returns
- Bool val
next
fun ref next()
: A ?
Returns
- A ?
next_or
Return the next value, or the given default.
Example
let x: (U64 | None) = 42
Iter[U64].maybe(x).next_or(0)
42
fun ref next_or(
default: A)
: A
Parameters
- default: A
Returns
- A
map_stateful[B: B]
Allows stateful transformation of each element from the iterator, similar to map
.
fun ref map_stateful[B: B](
f: {ref(A!): B^ ?}[A, B] ref)
: Iter[B] ref^
Parameters
- f: {ref(A!): B^ ?}[A, B] ref
Returns
- Iter[B] ref^
filter_stateful
Allows filtering of elements based on a stateful adapter, similar to filter
.
fun ref filter_stateful(
f: {ref(A!): Bool ?}[A] ref)
: Iter[A!] ref^
Parameters
- f: {ref(A!): Bool ?}[A] ref
Returns
- Iter[A!] ref^
filter_map_stateful[B: B]
Allows stateful modification to the stream of elements from an iterator, similar to filter_map
.
fun ref filter_map_stateful[B: B](
f: {ref(A!): (B^ | None) ?}[A, B] ref)
: Iter[B] ref^
Parameters
- f: {ref(A!): (B^ | None) ?}[A, B] ref
Returns
- Iter[B] ref^
all
Return false if at least one value of the iterator fails to match the predicate f
. This method short-circuits at the first value where the predicate returns false, otherwise true is returned.
Examples
Iter[I64]([2; 4; 6].values())
.all({(x) => (x % 2) == 0 })
true
Iter[I64]([2; 3; 4].values())
.all({(x) => (x % 2) == 0 })
false
fun ref all(
f: {(A!): Bool ?}[A] box)
: Bool val
Parameters
- f: {(A!): Bool ?}[A] box
Returns
- Bool val
any
Return true if at least one value of the iterator matches the predicate f
. This method short-circuits at the first value where the predicate returns true, otherwise false is returned.
Examples
Iter[I64]([2; 4; 6].values())
.any({(I64) => (x % 2) == 1 })
false
Iter[I64]([2; 3; 4].values())
.any({(I64) => (x % 2) == 1 })
true
fun ref any(
f: {(A!): Bool ?}[A] box)
: Bool val
Parameters
- f: {(A!): Bool ?}[A] box
Returns
- Bool val
collect[optional B: Seq[A!] ref]
Push each value from the iterator into the collection coll
.
Example
Iter[I64]([1; 2; 3].values())
.collect(Array[I64](3))
[1, 2, 3]
fun ref collect[optional B: Seq[A!] ref](
coll: B)
: B^
Parameters
- coll: B
Returns
- B^
count
Return the number of values in the iterator.
Example
Iter[I64]([1; 2; 3].values())
.count()
3
fun ref count()
: USize val
Returns
- USize val
cycle
Repeatedly cycle through the values from the iterator.
WARNING: The values returned by the original iterator are cached, so the input iterator should be finite.
Example
Iter[I64]([1; 2; 3].values())
.cycle()
1 2 3 1 2 3 1 2 3 ...
fun ref cycle()
: Iter[A!] ref^
Returns
- Iter[A!] ref^
enum[optional B: (Real[B] val & (I8 val | I16 val | I32 val | I64 val | I128 val | ILong val | ISize val | U8 val | U16 val | U32 val | U64 val | U128 val | ULong val | USize val | F32 val | F64 val))]
An iterator which yields the current iteration count as well as the next value from the iterator.
Example
Iter[I64]([1; 2; 3].values())
.enum()
(0, 1) (1, 2) (2, 3)
fun ref enum[optional B: (Real[B] val & (I8 val | I16 val | I32 val |
I64 val | I128 val | ILong val |
ISize val | U8 val | U16 val |
U32 val | U64 val | U128 val |
ULong val | USize val | F32 val |
F64 val))]()
: Iter[(B , A)] ref^
Returns
- Iter[(B , A)] ref^
filter
Return an iterator that only returns items that match the predicate f
.
Example
Iter[I64]([1; 2; 3; 4; 5; 6].values())
.filter({(x) => (x % 2) == 0 })
2 4 6
fun ref filter(
f: {(A!): Bool ?}[A] box)
: Iter[A!] ref^
Parameters
- f: {(A!): Bool ?}[A] box
Returns
- Iter[A!] ref^
find
Return the nth value in the iterator that satisfies the predicate f
.
Examples
Iter[I64]([1; 2; 3].values())
.find({(x) => (x % 2) == 0 })
2
Iter[I64]([1; 2; 3; 4].values())
.find({(x) => (x % 2) == 0 }, 2)
4
fun ref find(
f: {(A!): Bool ?}[A] box,
n: USize val = 1)
: A! ?
Parameters
- f: {(A!): Bool ?}[A] box
- n: USize val = 1
Returns
- A! ?
filter_map[B: B]
Return an iterator which applies f
to each element. If None
is returned, then the iterator will try again by applying f
to the next element. Otherwise, the value of type B
is returned.
Example
Iter[I64]([as I64: 1; -2; 4; 7; -5])
.filter_map[USize](
{(i: I64): (USize | None) => if i >= 0 then i.usize() end })
1 4 7
```pony
fun ref filter_map[B: B](
f: {(A!): (B^ | None) ?}[A, B] box)
: Iter[B] ref^
Parameters
- f: {(A!): (B^ | None) ?}[A, B] box
Returns
- Iter[B] ref^
flat_map[B: B]
Return an iterator over the values of the iterators produced from the application of the given function.
Example
Iter[String](["alpha"; "beta"; "gamma"])
.flat_map[U8]({(s: String): Iterator[U8] => s.values() })
a l p h a b e t a g a m m a
fun ref flat_map[B: B](
f: {(A!): Iterator[B] ?}[A, B] box)
: Iter[B] ref^
Parameters
- f: {(A!): Iterator[B] ?}[A, B] box
Returns
- Iter[B] ref^
fold[B: B]
Apply a function to every element, producing an accumulated value.
Example
Iter[I64]([1; 2; 3].values())
.fold[I64](0, {(sum, x) => sum + x })
6
fun ref fold[B: B](
acc: B,
f: {(B, A!): B^}[A, B] box)
: B^
Parameters
- acc: B
- f: {(B, A!): B^}[A, B] box
Returns
- B^
fold_partial[B: B]
A partial version of fold
.
fun ref fold_partial[B: B](
acc: B,
f: {(B, A!): B^ ?}[A, B] box)
: B^ ?
Parameters
- acc: B
- f: {(B, A!): B^ ?}[A, B] box
Returns
- B^ ?
last
Return the last value of the iterator.
Example
Iter[I64]([1; 2; 3].values())
.last()
3
fun ref last()
: A ?
Returns
- A ?
map[B: B]
Return an iterator where each item's value is the application of the given function to the value in the original iterator.
Example
Iter[I64]([1; 2; 3].values())
.map[I64]({(x) => x * x })
1 4 9
fun ref map[B: B](
f: {(A!): B^ ?}[A, B] box)
: Iter[B] ref^
Parameters
- f: {(A!): B^ ?}[A, B] box
Returns
- Iter[B] ref^
nth
Return the nth value of the iterator.
Example
Iter[I64]([1; 2; 3].values())
.nth(2)
2
fun ref nth(
n: USize val)
: A ?
Parameters
- n: USize val
Returns
- A ?
run
Iterate through the values of the iterator without a for loop. The function on_error
will be called if the iterator's has_next
method returns true but its next
method throws an error.
Example
Iter[I64]([1; 2; 3].values())
.map[None]({(x) => env.out.print(x.string()) })
.run()
1 2 3
fun ref run(
on_error: {ref()}[A] ref = lambda)
: None val
Parameters
- on_error: {ref()}[A] ref = lambda
Returns
- None val
skip
Skip the first n values of the iterator.
Example
Iter[I64]([1; 2; 3; 4; 5; 6].values())
.skip(3)
4 5 6
Iter[I64]([1; 2; 3].values())
.skip(3)
.has_next()
false
fun ref skip(
n: USize val)
: Iter[A] ref^
Parameters
- n: USize val
Returns
- Iter[A] ref^
skip_while
Skip values of the iterator while the predicate f
returns true.
Example
Iter[I64]([1; 2; 3; 4; 5; 6].values())
.skip_while({(x) => x < 4 })
4 5 6
fun ref skip_while(
f: {(A!): Bool ?}[A] box)
: Iter[A!] ref^
Parameters
- f: {(A!): Bool ?}[A] box
Returns
- Iter[A!] ref^
take
Return an iterator for the first n elements.
Example
Iter[I64]([1; 2; 3; 4; 5; 6].values())
.take(3)
1 2 3
fun ref take(
n: USize val)
: Iter[A] ref^
Parameters
- n: USize val
Returns
- Iter[A] ref^
take_while
Return an iterator that returns values while the predicate f
returns true. This iterator short-circuits the first time that f
returns false or raises an error.
Example
Iter[I64]([1; 2; 3; 4; 5; 6].values())
.take_while({(x) => x < 4 })
1 2 3
fun ref take_while(
f: {(A!): Bool ?}[A] box)
: Iter[A!] ref^
Parameters
- f: {(A!): Bool ?}[A] box
Returns
- Iter[A!] ref^
zip[B: B]
Zip two iterators together so that each call to next() results in a tuple with the next value of the first iterator and the next value of the second iterator. The number of items returned is the minimum of the number of items returned by the two iterators.
Example
Iter[I64]([1; 2].values())
.zip[I64]([3; 4].values())
(1, 3) (2, 4)
fun ref zip[B: B](
i2: Iterator[B] ref)
: Iter[(A , B)] ref^
Parameters
- i2: Iterator[B] ref
Returns
- Iter[(A , B)] ref^
zip2[B: B, C: C]
Zip three iterators together so that each call to next() results in a tuple with the next value of the first iterator, the next value of the second iterator, and the value of the third iterator. The number of items returned is the minimum of the number of items returned by the three iterators.
fun ref zip2[B: B, C: C](
i2: Iterator[B] ref,
i3: Iterator[C] ref)
: Iter[(A , B , C)] ref^
Parameters
Returns
- Iter[(A , B , C)] ref^
zip3[B: B, C: C, D: D]
Zip four iterators together so that each call to next() results in a tuple with the next value of each of the iterators. The number of items returned is the minimum of the number of items returned by the iterators.
fun ref zip3[B: B, C: C, D: D](
i2: Iterator[B] ref,
i3: Iterator[C] ref,
i4: Iterator[D] ref)
: Iter[(A , B , C , D)] ref^
Parameters
Returns
- Iter[(A , B , C , D)] ref^
zip4[B: B, C: C, D: D, E: E]
Zip five iterators together so that each call to next() results in a tuple with the next value of each of the iterators. The number of items returned is the minimum of the number of items returned by the iterators.
fun ref zip4[B: B, C: C, D: D, E: E](
i2: Iterator[B] ref,
i3: Iterator[C] ref,
i4: Iterator[D] ref,
i5: Iterator[E] ref)
: Iter[(A , B , C , D , E)] ref^
Parameters
Returns
- Iter[(A , B , C , D , E)] ref^
© 2016-2020, The Pony Developers
© 2014-2015, Causality Ltd.
Licensed under the BSD 2-Clause License.
https://stdlib.ponylang.io/itertools-Iter