integrant.core — org.dsteurer/mathdoc 0.1.25

build clj/s

(build config keys f)

Apply a function f to each key value pair in a configuration map. Keys are traversed in dependency order, and any references in the value expanded. The function should take two arguments, a key and value, and return a new value.

composite-keyword clj/s

(composite-keyword kws)

Return a unique keyword that is derived from an ordered collection of keywords. The function will return the same keyword for the same collection.

dependency-graph clj/s

(dependency-graph config)

Return a dependency graph of all the refs in a config. Resolve derived dependencies.

expand clj/s

(expand config)

Replace all refs with the values they correspond to.

find-derived clj/s

(find-derived m k)

Return a seq of all entries in a map, m, where the key is derived from the keyword, k. If there are no matching keys, nil is returned.

find-derived-1 clj/s

(find-derived-1 m k)

Return the map entry in a map, m, where the key is derived from the keyword, k. If there are no matching keys, nil is returned. If there is more than one matching key, an ambiguous key exception is raised.

halt! clj/s

(halt! system)

(halt! system keys)

Halt a system map by applying halt-key! in reverse dependency order.

halt-key! clj/s multimethod

(halt-key! key value)

Halt a running or suspended implementation associated with a key. This is often used for stopping processes or cleaning up resources. For example, a database connection might be closed. This multimethod must be idempotent. The return value of this multimethod is discarded.

init clj/s

(init config)

(init config keys)

Turn a config map into an system map. Keys are traversed in dependency order, initiated via the init-key multimethod, then the refs associated with the key are expanded.

init-key clj/s multimethod

(init-key key value)

Turn a config value associated with a key into a concrete implementation. For example, a database URL might be turned into a database connection.

load-namespaces clj

(load-namespaces config)

Attempt to load the namespaces referenced by the keys in a configuration. If a key is namespaced, both the namespace and the namespace concatenated with the name will be tried. For example, if a key is :foo.bar/baz, then the function will attempt to load the namespaces foo.bar and foo.bar.baz. Upon completion, a list of all loaded namespaces will be returned.

read-string clj

(read-string s)

(read-string opts s)

Read a config from a string of edn. Refs may be denotied by tagging keywords with #ref.

Ref cljs

ref clj/s

(ref key)

Create a reference to a top-level key in a config map.

ref? clj/s

(ref? x)

Return true if its argument is a ref.

resume clj/s

(resume config system)

(resume config system keys)

Turn a config map into a system map, reusing resources from an existing system when it's possible to do so. Keys are traversed in dependency order, resumed with the resume-key multimethod, then the refs associated with the key are expanded.

resume-key clj/s multimethod

(resume-key key value old-value old-impl)

Turn a config value associated with a key into a concrete implementation, but reuse resources (e.g. connections, running threads, etc) from an existing implementation. By default this multimethod calls init-key and ignores the additional argument.

reverse-run! clj/s

(reverse-run! system keys f)

Apply a side-effectful function f to each key value pair in a system map. Keys are traversed in reverse dependency order. The function should take two arguments, a key and value.

run! clj/s

(run! system keys f)

Apply a side-effectful function f to each key value pair in a system map. Keys are traversed in dependency order. The function should take two arguments, a key and value.

suspend! clj/s

(suspend! system)

(suspend! system keys)

Suspend a system map by applying suspend-key! in reverse dependency order.

suspend-key! clj/s multimethod

(suspend-key! key value)

Suspend a running implementation associated with a key, so that it may be eventually passed to resume-key. By default this multimethod calls halt-key!, but it may be customized to do things like keep a server running, but buffer incoming requests until the server is resumed.