Liking cljdoc? Tell your friends :D
Clojure only.

io.simplect.compose.notation


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

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

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

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]].
sourceraw docstring

λcljmacro

(λ & 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

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
sourceraw docstring

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

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

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

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

πclj

(π & args)

Notation for io.simplect.compose/partial1.

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 ((partial1 assoc :x 2) {:a 1})
             :ex2 (->> [{:a 1} {:v -1}]
                       (map (partial1 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 partial1 and Π for clojure.core/partial.

Notation for [[io.simplect.compose/partial1]].

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 ((partial1 assoc :x 2) {:a 1})
               :ex2 (->> [{:a 1} {:v -1}]
                         (map (partial1 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 `partial1` and `Π` for
  `clojure.core/partial`.
sourceraw docstring

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

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

χcljmacro

(χ & 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]].

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]].
sourceraw docstring

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close