Common utility functions and "extensions" to Clojure.
deps.edn:
clj -Sdeps '{:deps {worldsingles/ws-commons {:mvn/version "0.1.4"}}}'Leiningen / Boot Dependency:
[worldsingles/ws-commons "0.1.4"]condp->-- an extension tocond->that threads the expression through the predicate(s) as well as the result(s).condp->>-- an extension tocond->>that threads the expression through the predicate(s) as well as the result(s).condq-- a version ofcondpthat accepts a unary predicate and omits theexpr(thatcondpuses as the second argument to the predicate).dissoc-all-- an extension todissocthatdissoc's a sequence of keys.flip-- a companion topartialthat allows the first argument to be omitted (rather than the trailing arguments). Inspired by Haskell'sflip.interleave-all-- an extension tointerleavethat uses all elements of the longer sequence argument(s).")
A local binding capturing macro:
local-map-- returns a hash map containing all local symbols (as keyword keys) with their associated values; note that this can include auto-generated locals too!
In addition, some syntactic sugar for java.util.concurrent.CompletableFuture:
completable-- likefuturebut produces aCompletableFutureinstead.exceptionally-- applied to aCompletableFutureand a function, will execute the function on any exception produced by the future.then-- applied to aCompletableFutureand a function, will execute the function on the result of the future.
user=> (require '[ws.clojure.extensions :refer :all])
nil
;; threading examples:
user=> (defn f [n]
(condp-> n
even? (* 3)
(> 100) (- 100)))
#'user/f
user=> (f 22)
66 ; (* 22 3) = 66, (> 66 100) = false
user=> (f 66)
98 ; (* 66 3) = 198, (> 198 100) = true, (- 198 100)
user=> (defn g [n]
(condp->> n
even? (* 3)
(> 100) (- 100)))
#'user/g
user=> (g 22)
34 ; (* 3 22) = 66, (> 100 66) = true, (- 100 66) = 34
user=> (g 66)
198 ; (* 3 66) = 198, (> 100 198) = false
;; local-map examples:
user=> (let [a 1 b 2] (local-map)))
{:a 1, :b 2}
user=> (let [a 1 b 2] (local-map :only :a)))
{:a 1}
user=> (let [a 1 b 2] (local-map :only "a" b))
{:a 1, :b 2}
user=> (let [a 1 b 2] (local-map :without :a))
{:b 2}
user=> (defn foo [a b] ; a and b are also captured
(let [c 1 d (+ a b)]
{:all (local-map)
:a-d (local-map :only :a :d)
:b-c (local-map :without :a :d)}))
#'user/foo
user=> (foo 13 42)
{:all {:a 13, :b 42, :c 1, :d 55}
:a-d {:a 13, :d 55}
:b-c {:b 42, :c 1}}
user=> (let [{:keys [a b]} {:a 1, :b 2}] (local-map))
;; this will include the auto-generated :map# destructuring key as well
{:map__41744 {:a 1, :b 2}, :a 1, :b 2}
;; CompletableFuture examples:
user=> (deref (completable (Thread/sleep 5000) 42))
42 ; produces 42 after 5 seconds
user=> (deref (completable (Thread/sleep 5000) 42) 1000 13)
13 ; produces 13 after 1s
user=> (-> (completable (Thread/sleep 5000) 42)
(then #(/ 100 %))
(exceptionally ex-message)
(deref))
50/21 ; produces 50/21 after 5 seconds
user=> (-> (completable (Thread/sleep 5000) 0)
(then #(/ 100 %))
(exceptionally ex-message)
(deref)))
"java.lang.ArithmeticException: Divide by zero" ; produce "Divide by zero" after 5s
user=>Copyright © 2016-2024 World Singles Networks llc.
Distributed under the Eclipse Public License version 1.0.