threading.core — threading 0.3.2

*pp-lazy-max* clj

-• clj macro

(-• & forms)

See •-. Threads like ->.

-•• clj macro

(-•• & forms)

See •-. Threads like ->>.

<- clj macro

(<- first-expr second-expr)

As an equivalent to constantly, the anti-threading arrow is used to return an arbitrary value from a threading slot. The threaded expression will be evaluated although its value will be discarded. To be used in the context of a form threading in the style of ->.

<<- clj macro

(<<- first-expr second-expr)

As an equivalent to constantly, the anti-threading arrow is used to return an arbitrary value from a threading slot. The threaded expression will be evaluated although its value will be discarded. To be used in the context of a form threading in the style of ->>.

>- clj macro

(>- first-expr second-expr)

A threading fletching used to change the position at which the threaded form will be injected in the threading slots of the threading form. Transitions from a thread-first to a thread-last threading style.

>-> clj macro

(>-> threaded-expr expr)

Shorthand for `(>- (-> ...).

>->> clj macro

(>->> threaded-expr expr)

Shorthand for `(>- (->> ...).

>-args clj macro

(>-args first-expr second-expr)

Fletching that uses the arrow in the threading form to thread the expression in all subforms of its subform. form must have only one subform.

Fletching that moves the arrow in the threading form inside its subform's arguments. The threading arrow must have only one subform. Will thread the expr into the subforms with ->.

>>- clj macro

(>>- first-expr second-expr)

A threading fletching used to change the position at which the threaded form will be injected in the threading slots of the threading form. Transitions from a thread-last to a thread-first threading style.

>>-> clj macro

(>>-> expr threaded-expr)

Shorthand for `(>>- (-> ...).

>>->> clj macro

(>>->> expr threaded-expr)

Shorthand for `(>>- (->> ...).

>>-args clj macro

(>>-args first-expr second-expr)

Fletching that uses the arrow in the threading form to thread the expression in all subforms of its subform. form must have only one subform.

Fletching that moves the arrow in the threading form inside its subform's arguments. The threading arrow must have only one subform. Will thread the expr into the subforms with ->>.

and-> clj macro

(and-> expr & forms)

Threads expr through each form halting on a nil or false result. Threads like ->.

and->> clj macro

(and->> expr & forms)

Threads expr through each form halting on a nil or false result. Threads like ->>.

binding-> clj macro

(binding-> expr bindings & body)

Threads expr through each bound expression then through each form in body like binding. Threads like ->.

binding->> clj macro

(binding->> expr bindings & body)

Threads expr through each bound expression then through each form in body like binding. Threads like ->>.

defthreading clj macro

(defthreading & args)

Defines a threading arrow with variants.

Each variant is defined by a sequence like (name docstring? opts?).

The name of each defined threading arrow will consist in the variant symbol (usually -> and ->>) prefixed by thread-name if provided. Same goes for each arrow docstring: it will be prefixed with doc-prefix if provided.

The body will have access to some local variables defined under the hood:

• &threading-variant (mapped to the variant's name)
• &threading-opts (mapped to the variant's opts map if provided)

Keep in mind defthreading defines macros: the body should return Clojure code, not runtime values.

Example:

Consider this definition of tap with a custom ->debug threading variant:

(defmacro ->debug [& forms]
  `(-> ~@forms))

(defthreading tap
  "Some documentation."
  [-> "Some sufix for the documentation."
   ->> "Another documentation complement"
   ->debug {:debug true}] ;; No documentation here
  [expr & forms]
  `(let [result# ~expr]
     (when (:debug ~&threading-opts)
       (println "debug->:" result#))
     (~&threading-variant result# ~@forms)
     result#))

(tap->debug 1 (println ": perform some side-effect"))
;; debug->: 1
;; 1 : perform some side-effect.
;; => 1

Remarks:

• name is optional.
• name must be followed by the :prefix arrow-position to define fletchings.

if-> clj macro

(if-> expr test then)

(if-> expr test then else)

Threads expr through test then then or else. If else is not provided, returns expr when test fails. Threads like ->.

if->> clj macro

(if->> expr test then)

(if->> expr test then else)

Threads expr through test then then or else. If else is not provided, returns expr when test fails. Threads like ->>.

if-not-> clj macro

(if-not-> expr test then)

(if-not-> expr test then else)

Threads expr through test then then or else. If else is not provided, returns expr when test fails. Threads like ->.

if-not->> clj macro

(if-not->> expr test then)

(if-not->> expr test then else)

Threads expr through test then then or else. If else is not provided, returns expr when test fails. Threads like ->>.

juxt-> clj macro

(juxt-> expr & forms)

Threads expr through each form individually, collecting the results in a lazy sequence. Threads like ->.

juxt->> clj macro

(juxt->> expr & forms)

Threads expr through each form individually, collecting the results in a lazy sequence. Threads like ->>.

let-> clj macro

(let-> expr bindings & body)

Threads expr through each bound expression then through each form in body like let. Threads like ->.

let->> clj macro

(let->> expr bindings & body)

Threads expr through each bound expression then through each form in body like let. Threads like ->>.

map-> clj macro

(map-> expr & forms)

For an expr that will yield a sequence, threads each of its values through the forms. Threads like ->.

map->> clj macro

(map->> expr & forms)

For an expr that will yield a sequence, threads each of its values through the forms. Threads like ->>.

map-keys-> clj macro

(map-keys-> expr & forms)

For an expr that will yield an associative structure, threads each of its keys through the forms. Threads like ->.

map-keys->> clj macro

(map-keys->> expr & forms)

For an expr that will yield an associative structure, threads each of its keys through the forms. Threads like ->>.

map-vals-> clj macro

(map-vals-> expr & forms)

For an expr that will yield an associative structure, threads each of its values through the forms. Threads like ->.

map-vals->> clj macro

(map-vals->> expr & forms)

For an expr that will yield an associative structure, threads each of its values through the forms. Threads like ->>.

mapcat-> clj macro

(mapcat-> expr & forms)

For an expr that will yield a sequence, threads each of its values through the forms then returns the individual results concatenated together as a seq. Threads like ->.

mapcat->> clj macro

(mapcat->> expr & forms)

For an expr that will yield a sequence, threads each of its values through the forms then returns the individual results concatenated together as a seq. Threads like ->>.

mapv-> clj macro

(mapv-> expr & forms)

For an expr that will yield a sequence, threads each of its values through the forms. Returns the transformed sequence as a vector. Threads like ->.

mapv->> clj macro

(mapv->> expr & forms)

For an expr that will yield a sequence, threads each of its values through the forms. Returns the transformed sequence as a vector. Threads like ->>.

not-> clj macro

(not-> expr & forms)

Threads expr through the forms then returns the negated result. Threads like ->.

not->> clj macro

(not->> expr & forms)

Threads expr through the forms then returns the negated result. Threads like ->>.

or-> clj macro

(or-> expr & forms)

Threads expr through each expr halting on a non nil or false result. Threads like ->.

or->> clj macro

(or->> expr & forms)

Threads expr through each expr halting on a non nil or false result. Threads like ->>.

pp-> clj macro

(pp-> f & forms)

Like ->, but prints a debug statement for f and each expr in forms.

pp->> clj macro

(pp->> f & forms)

Like ->>, but prints a debug statement for f and each expr in forms.

tap clj macro

(tap expr & body)

Evaluates expressions in order returning the value of the first. Will thread the first expression into any immediate threading subexpressions.

(tap 123
     (println "yo")
     (some-> inc println))
; yo
; 124
; => 123

tap-> clj macro

(tap-> expr & forms)

Threads expr through forms then returns the value of the initial expression. Threads like ->.

tap->> clj macro

(tap->> expr & forms)

Threads expr through forms then returns the value of the initial expression. Threads like ->>.

when-> clj macro

(when-> expr test & forms)

Threads expr through test then the rest of the forms if it succeeds. Returns expr otherwise. Threads like ->.

when->> clj macro

(when->> expr test & forms)

Threads expr through test then the rest of the forms if it succeeds. Returns expr otherwise. Threads like ->>.

when-not-> clj macro

(when-not-> expr test & forms)

Threads expr through test then the rest of the forms if it fails. Returns expr otherwise. Threads like ->.

when-not->> clj macro

(when-not->> expr test & forms)

Threads expr through test then the rest of the forms if it fails. Returns expr otherwise. Threads like ->>.

•- clj macro

(•- first-expr second-expr)

Stores expr on the stack then threads it to form. In form, any deep occurence of the -• arrow will thread this value stored on the stack to its inner expressions.

Note that -• can only be used within the body of a •- form. Must be used in the context of a thread-first arrow.

••- clj macro

(••- first-expr second-expr)

Stores expr on the stack then threads it to form. In form, any deep occurence of the -• arrow will thread this value stored on the stack to its inner expressions.

Note that -• can only be used within the body of a •- form. Must be used in the context of a thread-last arrow.