1    Introduction

1.1    Installation

Add [xyz.zcaudate/std.lib "4.1.5"] to project.clj dependencies.

1.2    Top Level

The top level functionality in std.lib.stream are:

  • produce: Converts different data types (like ranges, lists, or even functions) into a uniform sequence that can be processed.
  • collect: Gathers the processed data into a desired output format, such as a vector, list, or a Java collection.
  • pipeline: Creates a composite transducer from a series of individual transformation steps, enabling complex data manipulation.
  • pipe: Connects a data source, a transformation pipeline, and a data sink to execute an entire stream operation.
  • producer: Creates a lazy sequence from a source and a pipeline, allowing on-demand data generation.
  • collector: Returns a function that, when given a source, collects the processed data into a specified sink after applying a pipeline.
  • stream / *>: A versatile function/macro that intelligently acts as a pipeline, producer, collector, or pipe based on the arguments provided, simplifying stream construction.

1.3    Produce

The produce function in std.lib.stream is designed to convert various data structures into a sequence, making them suitable for stream processing. Here are some examples of how it's used with different input types:

(require '[std.lib.stream :as s])

Producing from a range

(s/produce (range 5))
=> '(0 1 2 3 4)
(require '[std.lib.stream :as s])
(s/produce (fn [] 1))

;; If a function returns a sequence:

2    Walkthrough

2.1    Producing and collecting

produce turns different sources into a uniform sequence. collect consumes a sequence into a sink such as a vector, list, or Java collection.

produce a sequence from different sources

(s/produce (range 5))
=> '(0 1 2 3 4)

(s/produce [1 2 3])
=> [1 2 3]

(s/produce (fn [] 1))
=> '(1)

collect into various sinks

(s/collect [] (range 5))
=> [0 1 2 3 4]

(s/collect () (range 5))
=> '(4 3 2 1 0)

2.2    Pipelines and pipes

A pipeline is a composition of named transform steps. pipe wires a source, pipeline, and sink together in one call.

build and run a pipeline

(s/pipe (range 5)
        [[:map inc]
         [:map inc]]
        [])
=> [2 3 4 5 6]

filter and take elements

(s/pipe (range 20)
        [[:filter even?]
         [:take 5]
         [:map #(/ % 2)]]
        [])
=> [0 1 2 3 4]

2.3    Producers and collectors

producer returns a lazy sequence; collector returns a reusable function. Combine them to build reusable stream stages.

create a lazy producer

(take 3 (s/producer (range 100)
                    [[:map inc]
                     [:filter odd?]]))
=> '(3 5 7)

create a reusable collector

(let [collect-odds (s/collector [[:filter odd?]] [])]
  (collect-odds (range 10))
  => [1 3 5 7 9]

  (collect-odds [[:map inc]] (range 5))
  => [2 4])

2.4    The stream shorthand

stream (and the *> macro) chooses between pipe, producer, collector, and pipeline based on which connectors are supplied. Use <*> for a missing connector.

use stream as a pipe

(s/stream (range 5)
          [:map inc]
          [])
=> [1 2 3 4 5]

use stream as a producer

(s/stream (range 5)
          [:map inc]
          (s/<*>))
=> seq?

use stream as a collector

(let [collect+1 (s/stream (s/<*>)
                          [:map inc])]
  (collect+1 (range 5))
  => [1 2 3 4 5])

use the *> macro

(s/*> (range 5)
      (s/produce (range 1 6))
      [])
=> [1 2 3 4 5]

2.5    End-to-end: build a reusable data pipeline

A complete workflow: produce from a source, filter, transform, partition, and collect into a sink.

filter even numbers, pair them, and collect

(-> (s/pipe (range 10)
            [[:filter even?]
             [:partition-all 2]
             [:map vec]]
            [])
    (conj [8 9]))
=> [[0 2] [4 6] [8]]

3    Summary and Examples

The std.lib.stream library provides a powerful and flexible way to process data by composing transformations into pipelines. It extends Clojure's sequence and transducer capabilities, allowing you to define how data flows from various sources to different types of sinks.

4    core api

*> ^

[& args]
Added 3.0

shortcut for `stream`

v 3.0
(defmacro *>
  ([& args]
   `(stream ~@args)))
link
(*> (range 5)
    (i/i:map inc)
    [])
=> [1 2 3 4 5]

*transforms* ^

NONE
(defonce ^:dynamic *transforms*
  (atom {:map    i/i:map
         :map-indexed i/i:map-indexed
         :keep   i/i:keep
         :keep-indexed i/i:keep-indexed
         :filter  i/i:filter
         :remove   i/i:remove
         :take     i/i:take
         :take-nth i/i:take-nth
         :drop     i/i:drop
         :drop-last i/i:drop-last
         :butlast i/i:butlast
         :peek   i/i:peek
         :prn    i/i:prn
         :mapcat  i/i:mapcat
         :delay   i/i:delay
         :dedupe   i/i:dedupe
         :partition-all i/i:partition-all
         :partition-by i/i:partition-by
         :random-sample i/i:random-sample
         :sort     i/i:sort
         :sort-by  i/i:sort-by
         :reductions i/i:reductions
         :some   i/i:some
         :count  i/i:count
         :reduce i/i:reduce
         :max      i/i:max
         :min      i/i:min
         :mean     i/i:mean
         :stdev    i/i:stdev
         :last     i/i:last
         :str      i/i:str}))
link

+stream:base+ ^

NONE
(def +stream:base+
  '{java.util.stream.Stream
    {:produce produce-stream}
    java.util.stream.Collector
    {:collect collect-collector}})
link

+stream:clojure+ ^

NONE
(def +stream:clojure+
  (merge '{clojure.lang.ITransientCollection
           {:produce persistent! :collect collect-transient}
           clojure.lang.ISeq
           {:produce identity}}
         (zipmap '[clojure.lang.APersistentMap
                   clojure.lang.APersistentSet
                   clojure.lang.APersistentVector
                   clojure.lang.ASeq
                   clojure.lang.PersistentList
                   clojure.lang.PersistentList$EmptyList]
                 (repeat  {:produce identity :collect collect-persistent}))))
link

+stream:fn+ ^

NONE
(def +stream:fn+
  '{nil
    {:produce produce-nil :collect collect-nil}
    Object
    {:produce produce-object}
    clojure.lang.Fn
    {:produce produce-ifn :collect collect-ifn}
    Callable
    {:produce produce-callable}
    Supplier
    {:produce produce-supplier}})
link

+stream:future+ ^

NONE
(def +stream:future+
  '{Future
    {:produce produce-deref}
    clojure.lang.IDeref
    {:produce produce-deref}})
link

+stream:java+ ^

NONE
(def +stream:java+
  '{java.lang.Iterable
    {:produce iterator-seq}
    java.util.Collection
    {:produce seq}
    java.util.List
    {:produce seq}
    java.util.ArrayList
    {:produce seq :collect collect-collection}
    java.util.LinkedList
    {:produce seq :collect collect-collection}})
link

+stream:primitive+ ^

NONE
(def +stream:primitive+
  '{"[Z"
    {:produce seq :collect collect-booleans}
    "[B"
    {:produce seq :collect collect-bytes}
    "[C"
    {:produce seq :collect collect-chars}
    "[S"
    {:produce seq :collect collect-shorts}
    "[I"
    {:produce seq :collect collect-ints}
    "[J"
    {:produce seq :collect collect-longs}
    "[F"
    {:produce seq :collect collect-floats}
    "[D"
    {:produce seq :collect collect-doubles}})
link

+stream:promise+ ^

NONE
(def +stream:promise+)
link

<*> ^

[]
Added 3.0

denoting a missing connector

v 3.0
(defmacro <*>
  ([] :stream/<*>))
link
(<*>) => :stream/<*>

add-transforms ^

[key xform & more]
Added 3.0

adds a transform to the list

v 3.0
(defn add-transforms
  ([key xform & more]
   (let [args (apply vector key xform more)]
     (apply swap! *transforms* assoc args)
     (take-nth 2 args))))
link
(add-transforms :map i/i:map)
=> '(:map)

atom-seq ^

[atm f]
Added 3.0

constructs an atom-seq

v 3.0
(defn atom-seq
  ([atm f]
   (gen/gen (loop []
              (let [val (swap! atm f)]
                (gen/yield val)
                (recur))))))
link
(take 5 (atom-seq (atom -1) inc))
=> '(0 1 2 3 4)

collect ^

[sink supply] [sink xf supply]
Added 3.0

collection function given a seq supply

v 3.0
(defn collect
  ([sink supply]
   (collect sink identity supply))
  ([sink xf supply]
   (protocol.stream/-collect sink xf supply)))
link
(collect [] (range 5))
=> [0 1 2 3 4]

collect-collection ^

[sink xf supply]
Added 3.0

collect for java collections

v 3.0
(defn collect-collection
  ([^Collection sink xf supply]
   (reduce (fn [^Collection c e]
             (doto c (.add e)))
           sink
           (xf supply))))
link
(-> (collect-collection (java.util.ArrayList.)
                        (i/i:map inc)
                        (range 5)))
=> [1 2 3 4 5]

collect-collector ^

[sink xf supply]
Added 3.0

collects values from seq given a collector

v 3.0
(defn collect-collector
  ([^Collector sink xf supply]
   (-> (ISeqSpliterator/stream (seqiter xf supply))
       (.collect sink))))
link
(collect-collector (Collectors/toList)
                   (i/i:map inc)
                   (range 5))
=> [1 2 3 4 5]

collect-ifn ^

[f xf supply]
Added 3.0

collect outputs to a source

v 3.0
(defn collect-ifn
  ([^clojure.lang.Fn f xf supply]
   (let [s (seqiter xf supply)]
     (f s))))
link
(-> (collect-ifn int-array (i/i:map inc)
                 (range 5))
    seq)
=> '(1 2 3 4 5)

collect-nil ^

[_ xf supply]
Added 3.0

collect for nil

v 3.0
(defn collect-nil
  ([_ xf supply]
   (seqiter xf supply)))
link
(collect-nil nil (i/i:map inc)
             (range 5))
=> seq?

collect-persistent ^

[sink xf supply]
Added 4.1

collects into a persistent collection

v 4.1
(defn collect-persistent
  [sink xf supply]
  (into sink (xf supply)))
link
(collect-persistent [] (i/i:map inc) (range 5))
=> [1 2 3 4 5]
(collect-persistent #{} (i/i:map inc) (range 5))
=> #{1 2 3 4 5}

collect-promise ^

[sink xf supply]
Added 3.0

collects given a promise

v 3.0
(defn collect-promise
  ([sink xf supply]
   (deliver sink (first (seqiter xf supply)))))
link
@(doto (promise)
   (collect (i/i:map inc) (range 5)))
=> 1

collect-transient ^

[sink xf supply]
Added 3.0

collect for transients

v 3.0
(defn collect-transient
  ([^ITransientCollection sink xf supply]
   (reduce conj! sink (xf supply))))
link
(-> (collect-transient (transient [])
                       (i/i:map inc)
                       (range 5))
    (persistent!))
=> [1 2 3 4 5]

collector ^

[stages sink]
Added 3.0

creates a collection function

v 3.0
(defn collector
  ([stages sink]
   (let [xforms (pipeline stages)]
     (fn
       ([source]
        (collect sink xforms (produce source)))
       ([stages source]
        (collect sink
                 (comp (pipeline stages)
                       xforms)
                 (produce source)))))))
link
(collector [[:map inc]]
           [])
=> fn?

(pipe (producer (range 5)
                [[:map inc]])
      []
      (collector [[:map inc]]
                 []))
=> [2 3 4 5 6]

((collector [[:map inc]]
            [])
 (producer (range 5)
           [[:map inc]]))
=> [2 3 4 5 6]

((collector [[:map inc]]
            [])
 [[:map inc]]
 (producer (range 5)
           [[:map inc]]))
=> [3 4 5 6 7]

extend-stream ^

[all]
Added 3.0

extends the stream protocol for a map of types

v 3.0
(defmacro extend-stream
  ([all]
   (mapv extend-stream-form (cond (symbol? all)
                                  @(resolve all)

                                  :else all))))
link
(resolve 'extend-stream) => var?

extend-stream-form ^

[[type {:keys [produce collect]}]]
Added 3.0

extend protocols for a type

v 3.0
(defn extend-stream-form
  ([[type {:keys [produce collect]}]]
   (let [type (if (string? type)
                `(Class/forName ~type)
                type)]
     `(do (extend-type ~type
            ~@(if produce
                `[std.protocol.stream/ISource
                  (-produce [~'source] (~produce ~'source))])
            ~@(if collect
                `[std.protocol.stream/ISink
                  (-collect [~'sink ~'xf ~'supply] (~collect ~'sink ~'xf ~'supply))]))
          ~type))))
link
(extend-stream-form [nil '{:produce 'produce-nil
                           :collect 'collect-nil}])
=> any?

gen:primitives ^

[]
Added 3.0

generate primitive forms

v 3.0
(defmacro gen:primitives
  ([]
   (mapv primitive-form +stream:primitive+)))
link
(produce (byte-array 5))
=> '(0 0 0 0 0)

object-seq ^

[obj f]
Added 3.0

constructs an object-seq

v 3.0
(defn object-seq
  ([obj f]
   (gen/gen (loop []
              (let [e (f obj)]
                (gen/yield e)
                (recur))))))
link
(take 5 (object-seq (volatile! -1)
                    #(vswap! % inc)))
=> '(0 1 2 3 4)

pipe ^

[source stages sink]
Added 3.0

pipes data from one source into another

v 3.0
(defn pipe
  ([source stages sink]
   (let [xforms (pipeline stages)
         supply (produce source)]
     (collect sink xforms supply))))
link
(pipe (range 5)
      [[:map inc]
       [:map inc]]
      [])
=> [2 3 4 5 6]

pipeline ^

[stages]
Added 3.0

creates a transducer pipeline

v 3.0
(defn pipeline
  ([stages]
   (apply comp (reverse (pipeline-transform stages)))))
link
(pipeline [[:map inc]
           [:map inc]])
=> fn?

pipeline-transform ^

[stages]
Added 3.0

transforms a pipeline to transducer form

v 3.0
(defn pipeline-transform
  ([stages]
   (map (fn [xf]
          (cond (vector? xf)
                (let [[k & args] xf
                      f (or (get @*transforms* k)
                            (throw (ex-info "Invalid key" {:key k})))]
                  (apply f args))

                :else xf))
        stages)))
link
(pipeline-transform [[:map inc]
                     [:map inc]])
=> (contains [fn? fn?])

primitive-form ^

[[class {:keys [collect]}]]
Added 3.0

creates the primitive forms

v 3.0
(defn primitive-form
  ([[class {:keys [collect]}]]
   (let [fn-sym   collect
         sym-name (name collect)
         sym-name (subs sym-name (count "collect-") (dec (count sym-name)))
         aset-sym (symbol (str "aset-" sym-name))]
     `(defn ~fn-sym
        ([~'sink ~'xf ~'supply]
         (let [len#  (count ~'sink)
               xs#  (sequence ~'xf ~'supply)]
           (loop [i#   0
                  x#  (first xs#)
                  xs# (rest  xs#)]
             (if-not x#
               ~'sink
               (do (~aset-sym ~'sink i# x#)
                   (recur (inc i#) (first xs#) (rest xs#)))))))))))
link
(primitive-form '["[Z"
                  {:produce seq :collect collect-booleans}])

produce ^

[obj]
Added 3.0

produces a seq from an object

v 3.0
(defn produce
  ([obj]
   (protocol.stream/-produce obj)))
link
(produce (range 5))
=> '(0 1 2 3 4)

produce-callable ^

[f]
Added 3.0

produce for callable

v 3.0
(defn produce-callable
  ([^Callable f]
   (produce (.call f))))
link
(produce-callable (fn [] 1))
=> '(1)

produce-deref ^

[source]
Added 3.0

produces from a deref

v 3.0
(defn produce-deref
  ([source]
   (produce (deref source))))
link
(produce-deref (volatile! 1))
=> '(1)

produce-ifn ^

[f]
Added 3.0

produce for functions

v 3.0
(defn produce-ifn
  ([^clojure.lang.IFn f]
   (produce (.invoke f))))
link
(produce-ifn (fn [] 1)) => '(1)

(produce-ifn (fn [] (range 5)))
=> '(0 1 2 3 4)

produce-nil ^

[_]
Added 3.0

produce for nil

v 3.0
(defn produce-nil
  ([_]
   (list)))
link
(produce-nil nil) => ()

produce-object ^

[obj]
Added 3.0

default implementation of produce

v 3.0
(defn produce-object
  ([obj]
   (list obj)))
link
(produce-object 1) => '(1)

produce-stream ^

[source]
Added 3.0

produces values from a stream

v 3.0
(defn produce-stream
  ([^Stream source]
   (-> source .iterator iterator-seq)))
link
(->> (to-stream (range 5))
     (produce-stream)
     (map inc))
=> '(1 2 3 4 5)

produce-supplier ^

[f]
Added 3.0

produce for supplier

v 3.0
(defn produce-supplier
  ([^Supplier f]
   (.get f)))
link
(produce-supplier (fn/fn:supplier [] 1))
=> 1

producer ^

[source stages]
Added 3.0

creates a source seq

v 3.0
(defn producer
  ([source stages]
   (let [xforms (pipeline stages)]
     (seqiter xforms (produce source)))))
link
(producer (range 5)
          [[:map inc]])
=> seq?

seqiter ^

[coll] [xform coll]
Added 3.0

creates an non-chunking iterator from a transducer (sink)

v 3.0
(defn seqiter
  ([coll] coll)
  ([xform coll]
   (xform coll)))
link
(seqiter (i/i:map inc)
         (range 5))
=> (range 1 6)

stream ^

[source] [source & args]
Added 3.0

constructs a stream operation

v 3.0
(defn stream
  ([source] source)
  ([source & args]
   (let [[stages sink] [(butlast args) (last args)]
         source (if (= :<*> source) :stream/<*> source)
         sink   (if (= :<*> sink) :stream/<*> sink)]
     (cond (and (= :stream/<*> source)
                (= :stream/<*> sink))
           (pipeline stages)

           (= :stream/<*> sink)
           (producer source stages)

           (= :stream/<*> source)
           (collector stages sink)

           :else
           (pipe source stages sink)))))
link
;; pipe action
(stream (range 5)
        [:map inc]
        [:map inc]
        [])
=> [2 3 4 5 6]

;; producer
(stream (range 5)
        [:map inc]
        [:map inc]
        (<*>))
=> seq?


;; collector


(stream (<*>)
        [:map inc]
        [:map inc])
=> fn?

;; stage
(stream (<*>)
        [:map inc]
        [:map inc]
        (<*>))
=> fn?

to-stream ^

[arr]
Added 3.0

converts a seq to a stream

v 3.0
(defn to-stream
  [arr]
  (ISeqSpliterator/stream (seq arr)))
link

unit ^

[input] [xform input]
Added 3.0

applies a transducer to single input

v 3.0
(defn unit
  ([input] input)
  ([xform input]
   (first (seqiter xform [input]))))
link
(unit (i/i:map inc) 1)
=> 2

5    std.lib.stream: A Comprehensive Summary

The std.lib.stream module provides a powerful and flexible framework for processing sequences of data using transducers. It abstracts over various data sources (producers) and sinks (collectors), allowing for the construction of complex data pipelines with a unified API. The module extends Clojure's transducer capabilities with a rich set of custom transducers (xform namespace) and provides seamless integration with Java Streams and other collection types.

The module is organized into two main sub-namespaces:

5.1    std.lib.stream.xform

This namespace provides a comprehensive collection of transducers (transforming functions) that can be used in data processing pipelines. These transducers extend and complement Clojure's built-in transducers, offering functionalities for mapping, filtering, reducing, statistical analysis, and windowing.

  • x:map [& [f]]: A transducer that applies a function f to each element.n x:map-indexed [f]: A transducer that applies a function f to [index element] pairs.n x:filter [& [pred]]: A transducer that retains elements for which pred returns true.n x:remove [& [f]]: A transducer that removes elements for which f returns true.n x:keep [& [f]]: A transducer that retains non-nil results of applying f to each element.n x:keep-indexed [f]: A transducer that retains non-nil results of applying f to [index element] pairs.n x:prn [& [f]]: A transducer that prints each element (or (f element)) as a side effect.n x:peek [& [f]]: A transducer that applies f to each element as a side effect, returning the original element.n x:delay [ms]: A transducer that introduces a delay (in milliseconds) after processing each element.n x:mapcat [& [f]]: A transducer that maps a function f over elements and concatenates the results.n x:pass [& [init]]: An identity transducer.n x:apply [rf]: A transducer that applies a reduction function rf to the accumulated result.n x:reduce [f & [init]]: A transducer that accumulates results using a reduction function f.n x:take [& [n]]: A transducer that takes up to n elements.n x:take-last [n]: A transducer that takes the last n elements.n x:drop [& [n]]: A transducer that drops n elements from the beginning.n x:drop-last [n]: A transducer that drops the last n elements.n x:butlast []: A transducer that drops the last element.n x:some [& [f]]: A transducer that returns the first non-nil result of applying f to elements, or nil.n x:last []: A transducer that returns the last element.n x:count []: A transducer that counts the number of elements.n x:min [& [comparator]]: A transducer that finds the minimum element.n x:max [& [comparator]]: A transducer that finds the maximum element.n x:mean []: A transducer that calculates the mean of numeric elements.n x:stdev []: A transducer that calculates the standard deviation of numeric elements.n x:str []: A transducer that concatenates elements into a single string.n x:sort [& [cmp]]: A transducer that sorts all elements.n x:sort-by [xf & [cmp]]: A transducer that sorts elements based on a key function xf.n x:reductions [f & [init]]: A transducer that produces a sequence of intermediate reduction results.n x:wrap [open close]: A transducer that wraps the sequence with open and close elements.n x:time [tag-or-f xform]: A transducer that measures the time taken to process elements, printing the result.n* x:window [n & [f invf]]: A transducer that produces a sliding window of n elements.

5.2    std.lib.stream (Main Namespace)

This namespace provides the core API for constructing and executing data pipelines using transducers, integrating various data sources and sinks.

  • produce [obj]: A generic function (multimethod via protocol.stream/-produce) that converts an object into a sequence (producer).n collect [sink xf supply]: A generic function (multimethod via protocol.stream/-collect) that consumes a sequence supply (optionally transformed by xf) into a sink (collector).n seqiter [& [xform] coll & colls]: Creates a non-chunking iterator from a transducer and a collection, useful for fine-grained control over iteration.n unit [xform input]: Applies a transducer xform to a single input.n extend-stream-form [type-map]: Helper for extend-stream macro.n extend-stream [all]: A macro to extend std.protocol.stream/ISource and std.protocol.stream/ISink to various types based on a map of type-to-produce/collect functions.n *transforms*: An atom holding a map of all available transducers (from std.lib.stream.xform) keyed by their symbolic names.n add-transforms [key xform & more]: Adds custom transducers to *transforms*.n pipeline-transform [stages]: Converts a list of stage definitions (e.g., [:map inc]) into a list of actual transducer functions.n pipeline [stages]: Creates a composite transducer (pipeline) from a list of stage definitions.n pipe [source stages sink]: The core function for executing a stream. It takes a source, a list of stages (transducers), and a sink, piping data from source through stages to sink.n producer [source stages]: Creates a sequence producer from a source and a list of stages.n collector [stages sink]: Creates a collection function (sink) from a list of stages and a sink.n <*>: A keyword (:stream/<*>) used as a placeholder to denote a missing source or sink in stream operations.n stream [source & args]: A versatile function that constructs and executes stream operations. It can act as a pipeline, producer, collector, or pipe depending on whether <*> is used for source or sink.n *> [& args]: A shortcut macro for stream.n Producer/Collector Implementations:n produce-nil, produce-object, produce-ifn, produce-callable, produce-supplier: Functions to produce sequences from nil, generic objects, functions, Callables, and Suppliers.n collect-nil, collect-ifn: Functions to collect sequences into nil or by applying a function.n +stream:fn+: A map defining produce/collect implementations for various function-like types.n +stream:primitive+: A map defining produce/collect implementations for Java primitive arrays.n primitive-form [type-map]: Helper for gen:primitives.n gen:primitives []: A macro to generate produce/collect functions for primitive arrays.n collect-transient, collect-collection: Functions to collect sequences into ITransientCollections and java.util.Collections.n +stream:java+, +stream:clojure+: Maps defining produce/collect implementations for various Java and Clojure collection types.n to-stream [arr]: Converts a Clojure sequence to a java.util.stream.Stream.n produce-stream [source]: Produces a sequence from a java.util.stream.Stream.n collect-collector [sink xf supply]: Collects a sequence into a java.util.stream.Collector.n +stream:base+: Map defining produce/collect implementations for Java Streams and Collectors.n produce-deref [source]: Produces a sequence by dereferencing a source.n collect-promise [sink xf supply]: Collects a sequence into a Promise.n +stream:promise+, +stream:future+: Maps defining produce/collect implementations for Promises and Futures.n Sources:n atom-seq [atm f]: Constructs a lazy sequence by repeatedly updating and yielding values from an atom.n object-seq [obj f]: Constructs a lazy sequence by repeatedly applying a function f to an object and yielding the result.

Overall Importance:

The std.lib.stream module is a fundamental component for data processing and transformation within the foundation-base project. Its key contributions include:

  • Unified Data Processing API: Provides a consistent and flexible way to define and execute data pipelines, regardless of the underlying data source or sink.n Transducer-Based Efficiency: Leverages Clojure's transducers for efficient, composable, and lazy data transformations, minimizing intermediate allocations.n Extensibility: The protocol-driven design allows for easy integration of new data sources, sinks, and custom transducers.n Interoperability: Seamlessly integrates with various Java and Clojure collection types, as well as Java Streams, Callable, Supplier, Future, and Promise.n Rich Set of Transformations: The xform namespace provides a comprehensive library of transducers for common data manipulation, aggregation, and statistical analysis tasks.n* Declarative Pipeline Construction: The pipeline and stream functions allow for declarative definition of data processing workflows, improving readability and maintainability.

By offering these powerful streaming and data transformation capabilities, std.lib.stream significantly enhances the foundation-base project's ability to handle and process diverse data efficiently and flexibly, which is vital for its multi-language development ecosystem.

Related

jvm.artifactdocs

artifact coordinates and paths

jvm.classloaderdocs

classpath and classloaders

jvm.depsdocs

JVM dependency resolution

jvm.monitordocs

JVM metrics

jvm.namespacedocs

namespace management

jvm.protocoldocs

JVM extension protocols

jvm.reflectdocs

Java reflection

jvm.requiredocs

dependency-aware requiring