std/iteration

Modules

• std/iteration/collectorsCollectors decide where the values of a pipeline end up:
• std/iteration/concatenateOne step, and the reason the whole package needs it: putting many short texts together into one long one.
• std/iteration/iterationThe pull side of a pipeline: [Iterator], a cursor with one method, and [Iterate], anything that can hand one out.
• std/iteration/stageA stage is the middle of a pipeline, written once for both worlds: it turns an Accumulator<Output, Final> into an Accumulator<Input, Final>, a transducer in Clojure's word.
• std/iteration/stagedThe synchronous driver of a Stage: what Iterate.through(stage) answers.

Everything

• trait AccumulatorWhat to do with the values of a pipeline, and the state of doing it: values arrive one at a time through add, and finish produces the result once they have all arrived.
• fn averagingNone for an empty pipeline.
• fn chunkingGroups values into lists of at most size.
• fn collectorState is the starting point of every run.
• fn concatenatedThe pieces in one text, with separator between every two of them.
• fn countingHow many values there are.
• fn filteringKeeps every value that answers the predicate, and drops the rest.
• fn filterMappingmap and filter in one: keeps the value of every Some.
• fn flatMappingTransforms every value into its own Iterate, and flattens all of them into one sequence.
• fn groupingBy

  groupingBy { _.department }                              // Map<String, List<Employee>>     groupingBy { _.department }.then(counting())             // Map<String, Int>     groupingBy { _.department }.then(maxBy { _.salary }) // Map<String, Employee?>.
  

• fn indexing(0, first), (1, second), ... with the halves named index and item - the stage behind indexed().
• fn intoCollects into anything a pipeline can be turned into (From<Iterate<Item>>), which every collection is.
• trait IterateEverything that works with for ... in and the spread operator (...).
• trait IteratorA cursor over a sequence, with one method: next.
• fn joiningEvery value, joined into one String, with separator between values and prefix/suffix around all of them.
• trait LengthThe size of a collection, and the two questions built on it.
• type ListAccumulatorGathers the values into a List and answers it: the specialised accumulator this package ships, and the shape a package that owns a collection writes for its own (HashSetAccumulator writing straight into a set).
• fn listingShorthand for ListAccumulator<Item>(), which is what a pipeline ends in most often.
• fn mappingEvery stage is a function, not a member of Stage, for one reason: a member of a trait used as a namespace has to fix the trait's own type arguments, and Stage.filter could not (its answer says nothing about Output).
• fn mappingWhileLike filterMapping, but the first None ends the pipeline.
• fn maxByThe value with the largest key, or None for an empty pipeline.
• trait MergeTwo partial results of one accumulator, joined: what lets an accumulator run over pieces of its input - the chunks of parallel(), a divide-and-conquer fold, a map-reduce over the parts of a file - and still answer what one run over the whole input answers.
• fn mergingCollector[collector] with a [Merge]: merge joins the outputs of two pieces of the input, in their order, and is never handed the output of a piece that received no value.
• fn minByThe value with the smallest key, or None for an empty pipeline.
• fn partitioningBy(matching, rest).
• type QueueingThe tail of a pipeline that somebody pulls from: every value the stage pushes lands in a list the driver also holds.
• fn skippingEvery value after the first amount, which are read and thrown away.
• trait Stageonto is the whole protocol, and it is the reason a stage composes: what it answers is an Accumulator again, so the next stage can wrap that one.
• fn summingEvery value, added together, starting from zero.
• fn takingEnds the pipeline after amount values, and asks for none of the values behind them.
• fn takingWhileValues up to, but not including, the first one that fails the predicate.