stdlib::iter — glide doc

trait trait Iterator

fn fn iter_map(v: *Vector<T>, f: fn(T) -> U) -> *Vector<U>

Apply f to each element, returning a new Vector.

glide

fn double(x: int) -> int { return x * 2; }
let v: *Vector<int> = iter_range(1, 4);     // [1, 2, 3]
let m: *Vector<int> = iter_map(v, double);  // [2, 4, 6]

fn fn iter_filter(v: *Vector<T>, p: fn(T) -> bool) -> *Vector<T>

Keep only elements where p returns true.

glide

fn keep_pos(x: int) -> bool { return x > 0; }
let v: *Vector<int> = iter_range(-2, 3);          // [-2, -1, 0, 1, 2]
let pos: *Vector<int> = iter_filter(v, keep_pos); // [1, 2]

fn fn iter_take(v: *Vector<T>, n: int) -> *Vector<T>

First n elements (or all if n exceeds length).

glide

let v: *Vector<int> = iter_range(0, 10);
iter_take(v, 3);    // [0, 1, 2]
iter_take(v, 99);   // entire 10-element vector

fn fn iter_skip(v: *Vector<T>, n: int) -> *Vector<T>

Drop first n elements; return the rest.

glide

let v: *Vector<int> = iter_range(0, 5);   // [0,1,2,3,4]
iter_skip(v, 2);                          // [2, 3, 4]

fn fn iter_take_while(v: *Vector<T>, p: fn(T) -> bool) -> *Vector<T>

Take elements until p returns false (then stop).

glide

fn lt3(x: int) -> bool { return x < 3; }
let v: *Vector<int> = iter_range(0, 6);   // [0,1,2,3,4,5]
iter_take_while(v, lt3);                  // [0, 1, 2]

fn fn iter_skip_while(v: *Vector<T>, p: fn(T) -> bool) -> *Vector<T>

Skip elements while p returns true; keep the rest from first false.

glide

fn lt3(x: int) -> bool { return x < 3; }
let v: *Vector<int> = iter_range(0, 6);   // [0,1,2,3,4,5]
iter_skip_while(v, lt3);                  // [3, 4, 5]

fn fn iter_fold(v: *Vector<T>, init: U, f: fn(U, T) -> U) -> U

Fold over the vector. f(acc, item) returns the new accumulator.

glide

fn add(acc: int, x: int) -> int { return acc + x; }
let v: *Vector<int> = iter_range(1, 5);   // [1,2,3,4]
iter_fold(v, 0, add);                     // 10
iter_fold(v, 100, add);                   // 110

fn fn iter_count(v: *Vector<T>) -> int

Number of elements. Same as v.len(); provided for API symmetry.

glide

iter_count(iter_range(0, 5));   // 5

fn fn iter_any(v: *Vector<T>, p: fn(T) -> bool) -> bool

true if any element matches p. Short-circuits on first hit.

glide

fn is_neg(x: int) -> bool { return x < 0; }
let v: *Vector<int> = iter_range(-1, 3);   // [-1, 0, 1, 2]
iter_any(v, is_neg);                       // true

fn fn iter_all(v: *Vector<T>, p: fn(T) -> bool) -> bool

true if all elements match p. Short-circuits on first miss. Empty vector returns true (vacuous truth).

glide

fn is_pos(x: int) -> bool { return x > 0; }
let v: *Vector<int> = iter_range(1, 4);   // [1, 2, 3]
iter_all(v, is_pos);                      // true

fn fn iter_find(v: *Vector<T>, p: fn(T) -> bool) -> ?

First element matching p, or none if no match.

glide

fn is_even(x: int) -> bool { return x % 2 == 0; }
let v: *Vector<int> = iter_range(1, 5);   // [1,2,3,4]
match iter_find(v, is_even) {
    some(x) => println!(x),               // 2
    none()  => {},
}

fn fn iter_sum_int(v: *Vector<int>) -> int

Sum of int elements.

glide

let v: *Vector<int> = iter_range(1, 5);   // [1,2,3,4]
iter_sum_int(v);                          // 10

fn fn iter_max_int(v: *Vector<int>) -> ?

Max of int elements; none for empty vector.

glide

let v: *Vector<int> = Vector::new();  defer v.free();
v.push_all!(3, 7, 2, 9, 4);
iter_max_int(v);   // some(9)

fn fn iter_min_int(v: *Vector<int>) -> ?

Min of int elements; none for empty vector.

glide

let v: *Vector<int> = Vector::new();  defer v.free();
v.push_all!(3, 7, 2, 9, 4);
iter_min_int(v);   // some(2)

fn fn iter_range(start: int, end: int) -> *Vector<int>

[start, end) as a Vector<int>. Empty if end <= start.

glide

iter_range(0, 5);    // [0, 1, 2, 3, 4]
iter_range(3, 3);    // []
iter_range(2, 6);    // [2, 3, 4, 5]

fn fn iter_range_step(start: int, end: int, step: int) -> *Vector<int>

[start, start+step, start+2*step, ...) up to (but not including) end. Returns empty if step <= 0 or end <= start.

glide

iter_range_step(0, 10, 2);    // [0, 2, 4, 6, 8]
iter_range_step(10, 0, 1);    // []   (end <= start)
iter_range_step(0, 5, 0);     // []   (step <= 0)

fn fn iter_repeat(value: T, n: int) -> *Vector<T>

n copies of value. Empty if n <= 0.

glide

iter_repeat(0, 4);            // [0, 0, 0, 0]
iter_repeat("x", 3);          // ["x", "x", "x"]
iter_repeat(true, 0).len();   // 0