Conditions, protocol for communicating the causes of exceptions.

This provides infrastructure for building *condition* objects.
A condition object provides information about the cause of an exception.
Conditions thus form a protocol.

Clojure `ex-info` objects do not, by themselves, enough to form such
a protocol, as they do not allow classifying an exception easily.

This condition system builds on the design of
[R6RS Scheme](http://www.r6rs.org/final/html/r6rs-lib/r6rs-lib-Z-H-8.html#node_sec_7.2).

Condition objects are represented as specially marked `ex-info` objects.

One notable difference to the R6RS design is that there is no user-facing type for
'simple conditions', nor are they regular records.

{:top-level-setting-key 'foo
 {:section-key
  {:section-setting 'bar}}}

{:top-level-setting-key 'foo
 {:section-key
  {:section-setting 'bar}}
 {:profiles
  {:dev
   {:top-level-setting-key 'bar
    {:section-key
     {:section-setting 'baz}}}}}}

Application configuration via a big map.

A configuration is a nested key-value map.

It contains top-level settings and sections of qualified settings, like so:


    {:top-level-setting-key 'foo
     {:section-key
      {:section-setting 'bar}}}

Additionally, a config contains *profiles* with additional
settings that can be mixed in, like so:

    {:top-level-setting-key 'foo
     {:section-key
      {:section-setting 'bar}}
     {:profiles
      {:dev
       {:top-level-setting-key 'bar
        {:section-key
         {:section-setting 'baz}}}}}}

Each profile has the same format as the top-level configuration itself
  (sans the `:profiles` key).

Freer monads.

This is a variant of `active.clojure.monad` with a more efficient
representation for bind.

See http://okmij.org/ftp/Haskell/extensible/index.html for details.

Redefines higher order functions and function combinators from
clojure.core via applicable records (ifn? but not fn?). The
advantage is, that those objects compare = if they are created from
equal arguments. Disadvantages are that they are probably a bit
slower. They also don't implement some additional protocols like
Runnable yet.

(= (yank (shove data my-lens val)
         my-lens)
   val)

(= (shove data
          my-lens
          (yank data my-lens))
   data)

  (= (shove data my-lens val-1)
     (shove (shove data my-lens val-2) my-lens val-1))

Lenses should obey the following laws:

GetPut, or YankShove:

    (= (yank (shove data my-lens val)
             my-lens)
       val)

Meaning: you get back what you put in.

PutGet, or ShoveYank:

    (= (shove data
              my-lens
              (yank data my-lens))
       data)

Meaning: putting back what you got does not change anything.

PutPut, or ShoveShove:

      (= (shove data my-lens val-1)
         (shove (shove data my-lens val-2) my-lens val-1))

Meaning: second shove wins, or shoving once is the same as shoving twice.

A lens that satisfies these three laws is usually called "very well-behaved".
See also `active.clojure.lens-test/lens-laws-hold`.

Macro helpers.

Syntactic sugar for map matching around `core.match`.

Mock monadic programs

Monad related functionality, particularly free monads.

A re-implementation of `active.clojure.record` that makes use of
Clojure's new spec library. Define records the same ways as in the old
implementation or use the new syntax to automatically generate specs.
If a field has no explicit spec, defaults to `any?`.

Support for using `clojure.test` and conditions together.