trident.util — trident/datascript 0.1.16

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

avg clj/s

(avg xs)

capture clj/s macro

(capture & xs)

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)

condas-> clj/s macro

(condas-> expr name & clauses)

Combination of cond-> and as->.

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

doclines clj/s

(doclines _var)

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

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

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

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)

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.

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

ord clj/s

pad clj/s

(pad n _val coll)

parse-int clj/s

(parse-int s)

pprint clj/s

pred-> clj/s

(pred-> x f g)

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)

read-config clj

(read-config filename)

round clj/s

(round t)

(round t places)

split-by clj/s

(split-by pred xs)

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.