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.
An optional fourth argument, assertf, may be supplied to provide an assertion
check on the system, key and expanded value.

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

Return a dependency graph of all the refs and refsets in a config. Resolves
derived dependencies. Takes the following options:

`:include-refsets?`
: whether to include refsets in the dependency graph (defauls to true)

Return true if a key is derived from candidate keyword or vector of
keywords.

Replace all refs with the values they correspond to.

Return a seq of all entries in a map, m, where the key is derived from the
a candidate key, k. If there are no matching keys, nil is returned. The
candidate key may be a keyword, or vector of keywords.

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.

Reduce all the key value pairs in system map in dependency order, starting
from an initial value. The function should take three arguments: the
accumulator, the current key and the current value.

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

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.

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.

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

Create a key comparator from the dependency graph of a configuration map.
The comparator is deterministic; it will always result in the same key
order.

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.

Return a spec for the supplied key that is used to check the associated
value before the key is initiated.

Prepare a config map for initiation. The prep-key method is applied to each
entry in the map, and the values replaced with the return value. This is used
for adding default values and references to the configuration.

Prepare the configuration associated with a key for initiation. This is
generally used to add in default values and references. By default the
method returns the value unaltered.

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

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

Return true if its argument is a ref.

Return true if its argument is a ref or a refset.

Create a set of references to all matching top-level keys in a config map.

Return true if its argument is a refset.

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.

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.

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.

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 a system map by applying suspend-key! in reverse dependency order.

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.

Returns true if the key is a keyword or valid composite key.