#root::data

Iterator root/data/Iterator.vi

trait Iterator[Self, Item];

advance root/data/Iterator.vi:6

fn Iterator::advance[Self, Item; Iterator[Self, Item]](self: Self) -> Option[(Item, Self)];

empty root/data/Iterator.vi:10

const empty[T]: Empty[T];

Empty root/data/Iterator.vi:12

struct Empty[T](...);

one root/data/Iterator.vi:25

fn one[T](value: T) -> One[T];

One root/data/Iterator.vi:29

struct One[T](...);

from_next root/data/Iterator.vi:39

fn from_next[T, F; Fork[F], Drop[F], Fn[F, (), Option[T]]](f: F) -> FromNext[F];

FromNext root/data/Iterator.vi:43

struct FromNext[F](...);

map root/data/Iterator.vi:57

fn map[I, T, U, F; Iterator[I, T], Fork[F], Drop[F], Fn[F, (T,), U]](iter: I, f: F) -> Map[I, F];

Map root/data/Iterator.vi:61

struct Map[I, F](...);

filter root/data/Iterator.vi:74

fn filter[I, T, F; Iterator[I, T], Fork[F], Drop[F], Fn[F, (&T,), Bool]](iter: I, f: F) -> Filter[I, F];

Filter root/data/Iterator.vi:78

struct Filter[I, F](...);

filter_map root/data/Iterator.vi:100

fn filter_map[I, T, U, F; Iterator[I, T], Fork[F], Drop[F], Fn[F, (T,), Option[U]]](iter: I, f: F) -> FilterMap[I, F];

FilterMap root/data/Iterator.vi:104

struct FilterMap[I, F](...);

skip root/data/Iterator.vi:126

fn skip[I, T; Iterator[I, T], Drop[T]](iter: I, count: N32) -> Skip[I];

Skip root/data/Iterator.vi:130

struct Skip[I](...);

skip_while root/data/Iterator.vi:148

fn skip_while[I, T, F; Iterator[I, T], Drop[T], Fork[F], Drop[F], Fn[F, (&T,), Bool]](iter: I, f: F) -> SkipWhile[I, F];

SkipWhile root/data/Iterator.vi:152

struct SkipWhile[I, F](...);

chunks root/data/Iterator.vi:178

fn chunks[I, T; Iterator[I, T]](iter: I, size: N32) -> Chunks[I];

Returns an iterator of List[T]s, each with length size. The last value returned by this iterator may have length less than size, if the number of elements in iter is not evenly divisible by size.

If size is 0, lists of length 1 are returned in the iterator.

Chunks root/data/Iterator.vi:182

struct Chunks[I](...);

take root/data/Iterator.vi:212

fn take[I, T; Iterator[I, T], Drop[I]](iter: I, count: N32) -> Take[I];

Take root/data/Iterator.vi:216

struct Take[I](...);

take_while root/data/Iterator.vi:230

fn take_while[I, T, F; Iterator[I, T], Drop[I], Fork[F], Drop[F], Fn[F, (&T,), Bool]](iter: I, f: F) -> TakeWhile[I, F];

TakeWhile root/data/Iterator.vi:234

struct TakeWhile[I, F](...);

map_while root/data/Iterator.vi:248

fn map_while[I, T, U, F; Iterator[I, T], Drop[I], Fork[F], Drop[F], Fn[F, (T,), Option[U]]](iter: I, f: F) -> MapWhile[I, F];

MapWhile root/data/Iterator.vi:252

struct MapWhile[I, F](...);

zip root/data/Iterator.vi:266

fn zip[I, T, J, U; Iterator[I, T], Drop[I], Drop[T], Drop[J], Iterator[J, U]](i: I, j: J) -> Zip[I, J];

Zip root/data/Iterator.vi:270

struct Zip[I, J](...);

flatten root/data/Iterator.vi:284

fn flatten[I, J, T; Iterator[I, J], Iterator[J, T]](iter: I) -> Flatten[I, J];

Flatten root/data/Iterator.vi:288

struct Flatten[I, J](...);

flat_map root/data/Iterator.vi:309

fn flat_map[I, T, J, U, F; Iterator[I, T], Fork[F], Drop[F], Fn[F, (T,), J], Iterator[J, T]](iter: I, f: F) -> Flatten[Map[I, F], J];

concat root/data/Iterator.vi:315

impl concat[I, T, J; Iterator[I, T], Iterator[J, T]]: Concat[I, J, Concat[I, J]];

Concat root/data/Iterator.vi:321

struct Concat[I, J](...);

enumerate root/data/Iterator.vi:335

fn enumerate[I, T; Iterator[I, T]](iter: I) -> Map[I, Enumerate];

Enumerate root/data/Iterator.vi:339

struct Enumerate(...);

inspect root/data/Iterator.vi:351

fn inspect[I, T, F; Iterator[I, T], Fork[F], Drop[F], Fn[F, (&T,), ()]](iter: I, f: F) -> Map[I, Inspect[F]];

Inspect root/data/Iterator.vi:355

struct Inspect[F](...);
impl Inspect[T, F; Fork[F], Drop[F], Fn[F, (&T,), ()]]: Fn[Inspect[F], (T,), T];

forked root/data/Iterator.vi:366

fn forked[I, T; Iterator[I, &T], Fork[T]](iter: I) -> Map[I, fn #root::ops::flex::Fork::fork];

count root/data/Iterator.vi:370

fn count[I, T; Iterator[I, T], Drop[T]](iter: I) -> N32;

find root/data/Iterator.vi:378

fn find[I, T, F; Iterator[I, T], Drop[I], Drop[T], Fork[F], Drop[F], Fn[F, (&T,), Bool]](iter: I, f: F) -> Option[T];

find_map root/data/Iterator.vi:388

fn find_map[I, T, U, F; Iterator[I, T], Drop[I], Fork[F], Drop[F], Fn[F, (T,), Option[U]]](iter: I, f: F) -> Option[U];

for_each root/data/Iterator.vi:398

fn for_each[I, T, F; Iterator[I, T], Fork[F], Drop[F], Fn[F, (T,), ()]](iter: I, f: F);

fold root/data/Iterator.vi:404

fn fold[I, T, U, F; Iterator[I, T], Fork[F], Drop[F], Fn[F, (U, T), U]](iter: I, init: U, f: F) -> U;

reduce root/data/Iterator.vi:412

fn reduce[I, T, F; Iterator[I, T], Fork[F], Drop[F], Fn[F, (T, T), T]](iter: I, f: F) -> Option[T];

all root/data/Iterator.vi:419

fn all[I, T, F; Iterator[I, T], Drop[I], Fork[F], Drop[F], Fn[F, (T,), Bool]](iter: I, f: F) -> Bool;

any root/data/Iterator.vi:429

fn any[I, T, F; Iterator[I, T], Drop[I], Fork[F], Drop[F], Fn[F, (T,), Bool]](iter: I, f: F) -> Bool;

nth root/data/Iterator.vi:439

fn nth[I, T; Iterator[I, T], Drop[I], Drop[T]](iter: I, index: N32) -> Option[T];

last root/data/Iterator.vi:451

fn last[I, T; Iterator[I, T], Drop[I], Drop[T]](iter: I) -> Option[T];

max root/data/Iterator.vi:462

fn max[I, T; Iterator[I, T], Drop[T], Ord[T]](iter: I) -> Option[T];

min root/data/Iterator.vi:475

fn min[I, T; Iterator[I, T], Drop[T], Ord[T]](iter: I) -> Option[T];

Collect root/data/Iterator.vi:491

trait Collect[C, T];

Fused root/data/Iterator.vi:495

struct Fused[I](Option[I]);

Iterate root/data/Iterator.vi:513

trait Iterate[C, I, T];