io.simplect.compose.notation — io.simplect/compose 0.7.21

γ clj

(γ)

(γ f)

(γ f g)

(γ f g & fs)

Notation for [[clojure.core/comp]].

Takes a set of functions and returns a fn that is the composition of those fns. The returned fn takes a variable number of args, applies the rightmost of fns to the args, the next fn (right-to-left) to the result, etc.

Γ clj

(Γ & fs)

Notation for io.simplect.compose/rcomp.

Compose fs in order. Like [[clojure.core/comp]] except applies fs in the order they appear (reverse order relative to [[comp]]).

io.simplect.compose.notation defines the short-hand notation Γ for [[rcomp]] and γ for [[clojure.core/comp]].

λ clj macro

(λ & sigs)

Abbreviated form of [[clojure.core/fn]].

params => positional-params* , or positional-params* & next-param positional-param => binding-form next-param => binding-form name => symbol

Defines a function

μ clj

(μ f)

(μ f coll)

(μ f c1 c2)

(μ f c1 c2 c3)

(μ f c1 c2 c3 & colls)

Notation for [[clojure.core/map]].

Returns a lazy sequence consisting of the result of applying f to the set of first items of each coll, followed by applying f to the set of second items in each coll, until any one of the colls is exhausted. Any remaining items in other colls are ignored. Function f should accept number-of-colls arguments. Returns a transducer when no collection is provided.

Π clj

(Π f & args1)

Notation for io.simplect.compose/raptial.

Like partial except it will insert the argument accepted by the returned function between first and second elements of args (as opposed to [[partial]] which adds the argument after those given to it).

Example:

      user> {:ex1 ((raptial assoc :x 2) {:a 1})
             :ex2 (->> [{:a 1} {:v -1}]
                       (map (raptial assoc :x 2)))}
      {:ex1 {:a 1, :x 2},
       :ex2 ({:a 1, :x 2} {:v -1, :x 2})}
      user>

io.simplect.compose.notation defines the short-hand notation π for raptial and Π for clojure.core/partial.

π clj

(π f)

(π f arg1)

(π f arg1 arg2)

(π f arg1 arg2 arg3)

(π f arg1 arg2 arg3 & more)

Notation for [[clojure.core/partial]].

Takes a function f and fewer than the normal arguments to f, and returns a fn that takes a variable number of additional args. When called, the returned function calls f with args + additional args.

ρ clj

(ρ f coll)

(ρ f val coll)

Notation for [[clojure.core/reduce]].

f should be a function of 2 arguments. If val is not supplied, returns the result of applying f to the first 2 items in coll, then applying f to that result and the 3rd item, etc. If coll contains no items, f must accept no arguments as well, and reduce returns the result of calling f with no arguments. If coll has only 1 item, it is returned and f is not called. If val is supplied, returns the result of applying f to val and the first item in coll, then applying f to that result and the 2nd item, etc. If coll contains no items, returns val and f is not called.

χ clj macro

(χ & args)

Abbreviated form of io.simplect.compose/curry.

Same as cats.core/curry from the Funcool Cats library, its docstring reproduced below for convenience.

Given either a fixed arity function or an arity and a function, return another which is curried.

With inferred arity (function must have one fixed arity):

  (defn add2 [x y] (+ x y))
  (def cadd2 (curry add2))

  ((cadd2 1) 3)
  ;; => 4

  (cadd2 1 3)
  ;; => 4

With given arity:

  (def c+ (curry 3 +))

  ((c+ 1 2) 3)
  ;; => 6

  ((((c+) 1) 2) 3)
  ;; => 6

io.simplect.compose.notation defines the short-hand notation Χ for [[curry]].