trident.util — trident/build 0.2.2

Utility library. Docstrings are omitted for simple functions; read the source to see what they do.

add-seconds clj/s

(add-seconds date seconds)

assoc-not-empty clj/s

(assoc-not-empty m & kvs)

assoc-pred clj/s

(assoc-pred m f & kvs)

Like assoc, but skip kv pairs where (f v) is false.

assoc-some clj/s

(assoc-some m & kvs)

avg clj/s

(avg xs)

capture clj/s macro

(capture & xs)

capture-env clj/s macro

(capture-env nspace)

capture-env* clj/s

(capture-env* nspace)

catchall clj/s macro

(catchall & forms)

catchall-js clj/s macro

(catchall-js & forms)

ceil-at clj/s

(ceil-at x n)

chan? cljs

(chan? x)

char->int cljs

cljs-import-vars clj/s macro

(cljs-import-vars nspace & syms)

Like potemkin/import-vars but supports importing cljs-only functions.

Example:

(cljs-import-vars my.namespace.core
                  foo bar baz)

compare< clj/s

(compare< x y)

compare<= clj/s

(compare<= x y)

compare= clj/s

(compare= x y)

compare> clj/s

(compare> x y)

compare>= clj/s

(compare>= x y)

condas-> clj/s macro

(condas-> expr name & clauses)

Combination of cond-> and as->.

defcursors clj/s macro

(defcursors db & forms)

defderivations clj/s macro

(defderivations & args)

derivations clj

(derivations sources nspace & forms)

derive-config clj/s

(derive-config m)

Replaces any ^:derived values in m.

Example:

(def m
  {:first-name "John"
   :last-name  "Doe"
   :full-name ^:derived #(str (get-config % :first-name) " "
                              (get-config % :last-name))})

(derive-config m)
=> {:first-name "John" :last-name  "Doe" :full-name "John Doe"}

Any values with a truthy :derived metadata value must be single-argument functions. These functions will be replaced with their return values, with the config map as the argument.

get-config is like get, but if the return value is a :derived function, get-config will derive it before returning. It should be used within :derived function as in the example

dissoc-empty clj/s

(dissoc-empty m)

dissoc-vec clj/s

(dissoc-vec v i)

distinct-by clj/s

(distinct-by f xs)

doclines clj/s

(doclines _var)

Returns the docstring of a var as a collection of lines, removing indentation.

emptyish? clj/s

(emptyish? x)

flatten-form clj

(flatten-form form)

for-every? clj/s macro

(for-every? & forms)

for-some? clj/s macro

(for-some? & forms)

forcat clj/s macro

(forcat & forms)

format cljs

alias for goog.string.format

format-columns clj/s

(format-columns rows)

Formats rows of text into columns.

Example:

(doseq [row (format-columns [["hellooooooooo " "there"]
                             ["foo " "bar"]
                             ["one column"]])]
  (println row))
hellooooooooo there
foo           bar
one column

format-date clj

(format-date date out-format)

forv clj/s macro

(forv & body)

get-config clj/s

(get-config m k)

(get-config m k not-found)

See [derive-config].

get-in-config clj/s

(get-in-config m ks)

(get-in-config m ks not-found)

See [derive-config].

go-comp cljs

(go-comp & fs)

if-some-all clj/s macro

(if-some-all [& bindings] & [then else :as forms])

inherit clj/s macro

(inherit child-name [parent-instance :as fields] & overrides)

Like deftype but with default function implementations.

The first field is the "parent": for any protocol functions you don't define, the function will be called again with the parent as the first argument instead of the current object.

Example:

(defprotocol P
  (foo [this])
  (bar [this]))

(deftype Parent []
  P
  (foo [_] "parent foo")
  (bar [_] "parent bar"))

(inherit Child [parent]
  P
  (foo [_] "child foo"))

(def parent (Parent.))
(def child (Child. parent))

(foo child)
=> "child foo"
(bar child)
=> "parent bar"

instant? clj/s

(instant? x)

interleave-weighted clj/s

(interleave-weighted w coll-a coll-b)

js<! clj/s macro

(js<! form)

Like <! but for js promises. See to-chan.

load-fns clj/s macro

(load-fns & forms)

Defines a bunch of "dynamic functions" (see loadf).

Example:

(load-fns
  foo my.lib/foo
  bar my.lib/bar
  baz your.lib/baz)
(foo) ; same as (do (require 'my.lib) (my.lib/foo))

load-var clj

(load-var sym)

Dynamically loads a var.

sym: a fully-qualified var symbol.

loadf clj

(loadf sym)

Returns a function that dynamically loads and calls the specified function.

sym: a fully-qualified function symbol.

maintain-subscriptions cljs

(maintain-subscriptions sub-atom sub-fn)

Watch for changes in a set of subscriptions (stored in sub-atom), subscribing and unsubscribing accordingly. sub-fn should take an element of @sub-atom and return a channel that delivers the subscription channel after the first subscription result has been received. This is necessary because otherwise, old subscriptions would be closed too early, causing problems for the calculation of sub-atom.

map-from clj/s

(map-from f xs)

map-from-to clj/s

(map-from-to f g xs)

map-keys clj/s

(map-keys f m)

map-kv clj/s

(map-kv f m)

map-to clj/s

(map-to f xs)

map-vals clj/s

(map-vals f m)

maybe-slurp clj

(maybe-slurp f)

Attempts to slurp f, returning nil on failure

merge-subscription-results! cljs

(merge-subscription-results! {:keys [sub-data-atom merge-result sub-key
                                     sub-channel]})

Continually merge results from subscription into sub-data-atom. Returns a channel that delivers sub-channel after the first result has been merged.

now clj/s

(now)

ord clj/s

pad clj/s

(pad n _val coll)

parse-date clj

(parse-date date in-format)

parse-format-date clj

(parse-format-date date in-format out-format)

parse-int clj/s

(parse-int s)

parse-url clj/s

(parse-url url)

pprint clj/s

pred-> clj/s

(pred-> x f g)

prepend-keys clj/s

(prepend-keys ns-segment m)

prepend-ns clj/s

(prepend-ns ns-segment k)

print-table clj/s

(print-table header-info table)

Prints a nicely formatted table.

Example:

(print-table
  [[:foo "Foo"] [:bar "Bar"]]
  [{:foo 1 :bar 2} {:foo 3 :bar 4}])
=> Foo  Bar
   1    2
   3    4

rand-str clj/s

(rand-str len)

random-by clj/s

(random-by f xs)

read-config clj

(read-config filename)

respectively clj/s

(respectively & fs)

round clj/s

(round t)

(round t places)

sample-by clj/s

(sample-by f xs)

sh clj

(sh & args)

Runs a shell command.

Returns the output if successful; otherwise, throws an exception.

split-by clj/s

(split-by pred xs)

spy clj/s

(spy x)

synchronize cljs

(synchronize f)

Returns a fn that will queue calls to f, an async fn.

take-str clj/s

(take-str n s)

text clj/s macro

(text & forms)

Generates a string from pairs of conditions and lines of text.

The right-hand side values will be flattened, so you can give strings, collections of strings, or nested collections of strings. nils are removed.

Example:

(println (text
           true  ["foo" nil "bar"]
           false "baz"
           true  "quux"))
foo
bar
quux

to-chan cljs

(to-chan p)

Converts a js promise to a channel. If the promise throws an error, logs to the console and closes the channel.

when-some-all clj/s macro

(when-some-all [& bindings] & forms)

wrand clj/s

(wrand slices)

wrap-firebase-fn cljs

(wrap-firebase-fn handler)

wrap-vec clj/s

(wrap-vec x)

Use judiciously.