threading.core — threading 0.1.7

*pp-lazy-max* clj

<- clj macro

(<- & body)

Used to provide arbitrary input and output values to forms threading in the style of ->. The threaded form will be evaluated although its value will be discarded.

<<- clj macro

(<<- & body)

Like <- but must be used in the context of a form threading in the style of ->>.

>- clj macro

(>- first-expr last-expr)

A threading arrow 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)

>->> clj macro

(>->> expr threaded-expr)

>>- clj macro

(>>- first-expr last-expr)

A threading arrow 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)

>>->> clj macro

(>>->> threaded-expr expr)

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 ->>.

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 name-prefix 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

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 ->>.

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 ->>.

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 expr into any subsequent threading expr.

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

tap-> clj macro

(tap-> expr & forms)

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

tap->> clj macro

(tap->> expr & forms)

Threads the expr through the forms then returns the value of the initial expr. 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 ->>.