Check that the value of a key is correct immediately before the key is initiated. If the value is incorrect, an appropriate exception should be thrown.

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.

Deep-merge the values of a map. Raises an error on conflicting keys, unless an override is specified via the override-map.

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 (defaults to true)

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

Expand modules in the config map prior to initiation. The expand-key method is applied to each entry in the map to create an expansion, and the results are deep-merged together using converge to produce a new configuration.

If two expansions generate different values for the same keys, an exception will be raised. Configuration values that do not come from an expansion will override keys from expansions, allowing conflicts to be resolved by user- defined values.

Expand a config value into a map that is then merged back into the config. Defaults to returning a map {key value}. See: expand.

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

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.

Search the base classpath for all resources that share the same path (by default integrant/hierarchy.edn), and use their contents to extend the global derive hierarchy. This allows a hierarchy to be constructed without needing to load every namespace.

The hierarchy resources should be edn files that map child keywords to vectors of parents. For example:

{:example/child [:example/father :example/mother]}

This is equivalent:

(derive :example/child :example/father)
(derive :example/child :example/mother)

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.

Given a valid Integrant key, return a keyword that uniquely identifies it.

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.

Deprecated in favor of expand.

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.

Return a value to substitute for a reference prior to initiation. By default the value of the key is returned unaltered. This can be used to hide information that is only necessary to halt or suspend the key.

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

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.

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