Std.Iter

25 public declarations

• count&Q -> Int where Q: Sequence

  How many items a sequence yields.

  fn
• dropQ -> Int -> Std.Iter.Dropped[Q, T]

  Everything after the first `skip` items.

  fn
• Dropped

  A sequence of another's items past the first `skip`.

  type
• emptyStd.Iter.Empty[T]

  The sequence with no items.

  fn
• Empty

  A walk that yields nothing.

  type
• filterQ -> fn(T) -> Bool -> Std.Iter.Filtered[Q, T]

  Keep only the items a test accepts.

  fn
• Filtered

  A sequence of another's items that satisfy a test.

  type
• indexedArray[T] -> Std.Iter.Indexed[T]

  Pair each of an array's items with its position.

  fn
• Indexed

  A walk over an array's items paired with their positions.

  type
• isEmpty&Q -> Bool where Q: Sequence

  Whether a sequence yields nothing.

  fn
• itemsArray[T] -> Std.Iter.Items[T]

  Walk an array's items.

  fn
• Items

  A walk over an array's items.

  type
• mapQ -> fn(A) -> B -> Std.Iter.Mapped[Q, A, B]

  Transform each item of a sequence as it is produced.

  fn
• Mapped

  A sequence whose items are another's, transformed.

  type
• rangeN -> N -> Std.Iter.Range[N]

  The numbers from `first` up to but not including `last`.

  fn
• Range

  A half-open range of whole numbers, from `first` up to but not including

  type
• repeatT -> Int -> Std.Iter.Repeated[T]

  The same value, `count` times.

  fn
• Repeated

  A walk that yields the same item a fixed number of times.

  type
• Sequence

  A value that produces a sequence of items.

  trait
• sum&Q -> Option[N] where N: Add, Q: Sequence

  The sum of a sequence's items, or `None` when it has no first value.

  fn
• takeQ -> Int -> Std.Iter.Taken[Q, T]

  The first `limit` items, or all of them if there are fewer.

  fn
• Taken

  A sequence of at most the first `limit` items of another.

  type
• toArray&Q -> Array[T] where Q: Sequence

  Collect a sequence into an array.

  fn
• zipP -> Q -> Std.Iter.Zipped[P, Q, A, B]

  Pair two sequences, ending when either does.

  fn
• Zipped

  A sequence pairing two others item by item.

  type