#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](...);

take root/data/Iterator.vi:173

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

Take root/data/Iterator.vi:177

struct Take[I](...);

take_while root/data/Iterator.vi:191

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:195

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

map_while root/data/Iterator.vi:209

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:213

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

zip root/data/Iterator.vi:227

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:231

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

flatten root/data/Iterator.vi:245

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

Flatten root/data/Iterator.vi:249

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

flat_map root/data/Iterator.vi:270

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:276

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

Concat root/data/Iterator.vi:282

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

enumerate root/data/Iterator.vi:296

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

Enumerate root/data/Iterator.vi:300

struct Enumerate(...);

inspect root/data/Iterator.vi:312

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:316

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

forked root/data/Iterator.vi:327

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

count root/data/Iterator.vi:331

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

find root/data/Iterator.vi:339

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:349

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:359

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:365

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:373

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:380

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:390

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:400

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

last root/data/Iterator.vi:412

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

Collect root/data/Iterator.vi:426

trait Collect[C, T];

Fused root/data/Iterator.vi:430

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

Iterate root/data/Iterator.vi:448

trait Iterate[C, I, T];