Associates `k` to `v` in `m` only if `k` is not present in `m`.

Returns the average of the numbers `vs`; a la clj min/max

Returns true if `v` is between `min` and `max`, inclusive of both.

Tries `f`. If `f` throws a `Throwable`, it is caught and returned.

Clamps number `n` between `min` and `max` inclusive of each. When called with
only two args, produces a transducer.

Like merge, but recursive.

Like `merge-with`, but recursive so it works more than 1-level deep.

Macro for compiling some data at build time from an edn file, to avoid
runtime lookups to the file.

Roughly equivalent to `(update-in m ks disj elem)`, except that empty sets
are dissociated.

Dissociates `k` from `m` only if `(get m k)` equals `expected`.

Double-escapes double-quotes in `s`.

Sets the value of `atom` to `newval` without regard for the current value.
Returns the previous value of `atom`.

Atomically swaps the value of atom to be:
`(apply f current-value-of-atom args)`. Note that f may be called multiple
times, and thus should be free of side effects.
Returns the last `current-value-of-atom` before swap.

Maps `f` on the vals of `m`, producing a new map with the same keys.

Returns true if either `val` is nil or `(pred? val)` returns truthful.

Useful for situations where `nil` is acceptable, but when non-nil `val` is
expected to meet some criterion.

Examples:

    (maybe? map? m)
    (maybe? string? s)

Returns [(min coll) (max coll)] while iterating coll only once

As named. Equivalent to `(or (pos? v) (zero? v))`.

Returns `s` surrounded by double-quotes.

Returns vector `v` with index `i` removed.  `v` is nil, returns nil. `i` must
be a 0-indexed integer between 0 and the length of `v`.

Tries to execute `body` up to the number of times specified or until `pred?` returns
truthful given the result of executing `body`.

Tries to execute `f` up to the number of times specified or until `pred?` returns
truthful given the result of executing `f`. If `f` throws, the thrown value is caught
and passed to `pred?`.

This can be used to retry until a non-Exception response, like so:
```
(retry* 5 (complement #(instance? Throwable %)) some-fn)
```

Or, used to retry until a non-nil response, like so:
```
(retry* 5 (complement nil?) some-fn)
```

When `n` retries are reached, the result of the final `f` will be returned or thrown
if it is throwable, regardless of `pred?`.

Rounds a number to the specified precision. This is a modified version of the
round fn used here: http://clojure-doc.org/articles/language/functions.html
Compared to the reference, the argument order is reversed so it is more easily
used in partially applied form as a map fn. When called with only a precision,
returns a transducer.

Suppresses any exceptions that are thrown, returning nil instead.

Evaulates equality by converting all args to strings and then testing with
string equality. Useful when comparing stringy values that may not all be
strings, such as `1`, `"1"`, and `:1`.

Executes `body` in a new thread. Like `future`, except it returns the thread
instead of the result of `body`.

Implementation detail.

If `v` is a Throwable, throws `v`. Otherwise, returns `v`.