shortcut for stream

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

denoting a missing connector

(<>) => :stream/<>

adds a transform to the list

(add-transforms :map x/x:map) => ’(:map)

constructs an atom-seq

(take 5 (atom-seq (atom -1) inc)) => ’(0 1 2 3 4)

collection function given a seq supply

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

collect for java collections

(-> (collect-collection (java.util.ArrayList.) (map inc) (range 5))) => 1 2 3 4 5

collects values from seq given a collector

(collect-collector (Collectors/toList) (map inc) (range 5)) => 1 2 3 4 5

collect outputs to a source

(-> (collect-ifn int-array (map inc) (range 5)) seq) => ’(1 2 3 4 5)

collect for nil

(collect-nil nil (map inc) (range 5)) => seq?

collects given a promise

@(doto (promise) (collect (map inc) (range 5))) => 1

collect for transients

(-> (collect-transient (transient []) (map inc) (range 5)) (persistent!)) => 1 2 3 4 5

creates a collection function

(collector :map inc []) => fn?

extends the stream protocol for a map of types

extend protocols for a type

(extend-stream-form nil ’{:produce ’produce-nil :collect ’collect-nil})

generate primitive forms

(produce (byte-array 5)) => ’(0 0 0 0 0)

constructs an object-seq

(take 5 (object-seq (volatile! -1) #(vswap! % inc))) => ’(0 1 2 3 4)

pipes data from one source into another

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

creates a transducer pipeline

(pipeline [:map inc :map inc :window 5]) => fn?

transforms a pipeline to transducer form

(pipeline-transform [:map inc :map inc :window 5]) => (contains fn? fn? fn?)

creates the primitive forms

(primitive-form ’["Z" {:produce seq :collect collect-booleans})

produces a seq from an object

(produce (range 5)) => ’(0 1 2 3 4)

produce for callable

(produce-callable (fn [] 1)) => ’(1)

produces from a deref

(produce-deref (volatile! 1)) => ’(1)

produce for functions

(produce-ifn (fn [] 1)) => ’(1)

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

produce for nil

(produce-nil nil) => ()

default implementation of produce

(produce-object 1) => ’(1)

produces values from a stream

(->> (to-stream (range 5)) (produce-stream) (map inc)) => ’(1 2 3 4 5)

produce for supplier

(produce-supplier (fn/fn:supplier [] 1)) => 1

creates a source seq

(producer (range 5) :map inc) => seq?

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

(seqiter (map inc) (range 5)) => (range 1 6)

constructs a stream operation

converts a seq to a stream

applies a transducer to single input

(unit (map inc) 1) => 2