From a75f032ff219fdd639580455a6d3e83fd05d5592 Mon Sep 17 00:00:00 2001
From: Eduardo Julian
Date: Sat, 6 Apr 2019 21:14:27 -0400
Subject: Created the "lux/abstract" branch and moved some modules into it.

---
 stdlib/source/lux.lux                              |   6 +-
 stdlib/source/lux/abstract/algebra.lux             |  17 ++
 stdlib/source/lux/abstract/apply.lux               |  36 +++
 stdlib/source/lux/abstract/codec.lux               |  27 +++
 stdlib/source/lux/abstract/comonad.lux             |  62 +++++
 stdlib/source/lux/abstract/enum.lux                |  21 ++
 stdlib/source/lux/abstract/equivalence.lux         |  42 ++++
 stdlib/source/lux/abstract/fold.lux                |  18 ++
 stdlib/source/lux/abstract/functor.lux             |  32 +++
 stdlib/source/lux/abstract/hash.lux                |  13 ++
 stdlib/source/lux/abstract/interval.lux            | 184 +++++++++++++++
 stdlib/source/lux/abstract/monad.lux               | 168 ++++++++++++++
 stdlib/source/lux/abstract/monad/free.lux          |  67 ++++++
 stdlib/source/lux/abstract/monad/indexed.lux       |  64 ++++++
 stdlib/source/lux/abstract/monoid.lux              |  19 ++
 stdlib/source/lux/abstract/number.lux              |  14 ++
 stdlib/source/lux/abstract/order.lux               |  59 +++++
 stdlib/source/lux/abstract/predicate.lux           |  57 +++++
 stdlib/source/lux/cli.lux                          |  17 +-
 stdlib/source/lux/control/algebra.lux              |  17 --
 stdlib/source/lux/control/apply.lux                |  36 ---
 stdlib/source/lux/control/codec.lux                |  29 ---
 stdlib/source/lux/control/comonad.lux              |  62 -----
 stdlib/source/lux/control/concatenative.lux        |   7 +-
 stdlib/source/lux/control/concurrency/actor.lux    |   4 +-
 stdlib/source/lux/control/concurrency/atom.lux     |   2 +-
 stdlib/source/lux/control/concurrency/frp.lux      |   5 +-
 stdlib/source/lux/control/concurrency/process.lux  |   3 +-
 stdlib/source/lux/control/concurrency/promise.lux  |   2 +-
 .../source/lux/control/concurrency/semaphore.lux   |   3 +-
 stdlib/source/lux/control/concurrency/stm.lux      |   2 +-
 stdlib/source/lux/control/continuation.lux         |   2 +-
 stdlib/source/lux/control/contract.lux             |   2 +-
 stdlib/source/lux/control/enum.lux                 |  21 --
 stdlib/source/lux/control/equivalence.lux          |  42 ----
 stdlib/source/lux/control/exception.lux            |   3 +-
 stdlib/source/lux/control/fold.lux                 |  18 --
 stdlib/source/lux/control/functor.lux              |  32 ---
 stdlib/source/lux/control/hash.lux                 |  13 --
 stdlib/source/lux/control/interval.lux             | 184 ---------------
 stdlib/source/lux/control/monad.lux                | 168 --------------
 stdlib/source/lux/control/monad/free.lux           |  67 ------
 stdlib/source/lux/control/monad/indexed.lux        |  64 ------
 stdlib/source/lux/control/monoid.lux               |  19 --
 stdlib/source/lux/control/number.lux               |  14 --
 stdlib/source/lux/control/order.lux                |  60 -----
 stdlib/source/lux/control/parser.lux               |  14 +-
 stdlib/source/lux/control/pipe.lux                 |   3 +-
 stdlib/source/lux/control/predicate.lux            |  53 -----
 stdlib/source/lux/control/reader.lux               |   4 +-
 stdlib/source/lux/control/region.lux               |   9 +-
 stdlib/source/lux/control/remember.lux             |   3 +-
 stdlib/source/lux/control/security/capability.lux  |   3 +-
 stdlib/source/lux/control/security/integrity.lux   |   2 +-
 stdlib/source/lux/control/security/privacy.lux     |   2 +-
 stdlib/source/lux/control/state.lux                |   2 +-
 stdlib/source/lux/control/thread.lux               |   2 +-
 stdlib/source/lux/control/writer.lux               |   2 +-
 stdlib/source/lux/data/bit.lux                     |  19 +-
 stdlib/source/lux/data/collection/array.lux        |   2 +-
 stdlib/source/lux/data/collection/bits.lux         |   3 +-
 stdlib/source/lux/data/collection/dictionary.lux   |   2 +-
 .../lux/data/collection/dictionary/ordered.lux     |   2 +-
 stdlib/source/lux/data/collection/list.lux         |   2 +-
 stdlib/source/lux/data/collection/queue.lux        |   2 +-
 .../source/lux/data/collection/queue/priority.lux  |   2 +-
 stdlib/source/lux/data/collection/row.lux          |  13 +-
 stdlib/source/lux/data/collection/sequence.lux     |   7 +-
 stdlib/source/lux/data/collection/set.lux          |   2 +-
 stdlib/source/lux/data/collection/set/multi.lux    |   2 +-
 stdlib/source/lux/data/collection/set/ordered.lux  |   2 +-
 stdlib/source/lux/data/collection/stack.lux        |   2 +-
 stdlib/source/lux/data/collection/tree/finger.lux  |   2 +-
 stdlib/source/lux/data/collection/tree/rose.lux    |   5 +-
 .../lux/data/collection/tree/rose/zipper.lux       |   2 +-
 stdlib/source/lux/data/color.lux                   |   2 +-
 stdlib/source/lux/data/env.lux                     |   2 +-
 stdlib/source/lux/data/error.lux                   |  15 +-
 stdlib/source/lux/data/format/binary.lux           |   9 +-
 stdlib/source/lux/data/format/context.lux          |   5 +-
 stdlib/source/lux/data/format/json.lux             |   7 +-
 stdlib/source/lux/data/format/xml.lux              |   5 +-
 stdlib/source/lux/data/identity.lux                |   2 +-
 stdlib/source/lux/data/lazy.lux                    |   5 +-
 stdlib/source/lux/data/maybe.lux                   |   2 +-
 stdlib/source/lux/data/name.lux                    |   2 +-
 stdlib/source/lux/data/number.lux                  |   2 +-
 stdlib/source/lux/data/number/complex.lux          |   5 +-
 stdlib/source/lux/data/number/frac.lux             |   2 +-
 stdlib/source/lux/data/number/i64.lux              |   2 +-
 stdlib/source/lux/data/number/int.lux              |   2 +-
 stdlib/source/lux/data/number/nat.lux              |   2 +-
 stdlib/source/lux/data/number/ratio.lux            |   9 +-
 stdlib/source/lux/data/number/rev.lux              |   2 +-
 stdlib/source/lux/data/store.lux                   |   2 +-
 stdlib/source/lux/data/text.lux                    |  22 +-
 stdlib/source/lux/data/text/encoding.lux           |   2 +-
 stdlib/source/lux/data/text/format.lux             |   3 +-
 stdlib/source/lux/data/text/lexer.lux              |   3 +-
 stdlib/source/lux/data/text/regex.lux              |   3 +-
 stdlib/source/lux/data/text/unicode.lux            |   2 +-
 stdlib/source/lux/data/trace.lux                   |   2 +-
 stdlib/source/lux/function.lux                     |   7 +-
 stdlib/source/lux/host.js.lux                      |   3 +-
 stdlib/source/lux/host.jvm.lux                     |   5 +-
 stdlib/source/lux/host/jvm/attribute.lux           |   5 +-
 stdlib/source/lux/host/jvm/class.lux               |   5 +-
 stdlib/source/lux/host/jvm/constant.lux            |   5 +-
 stdlib/source/lux/host/jvm/constant/pool.lux       |   5 +-
 stdlib/source/lux/host/jvm/constant/tag.lux        |   2 +-
 stdlib/source/lux/host/jvm/encoding.lux            |   3 +-
 stdlib/source/lux/host/jvm/field.lux               |   5 +-
 stdlib/source/lux/host/jvm/index.lux               |   2 +-
 stdlib/source/lux/host/jvm/loader.jvm.lux          |   3 +-
 stdlib/source/lux/host/jvm/method.lux              |   5 +-
 stdlib/source/lux/host/jvm/modifier.lux            |   5 +-
 stdlib/source/lux/host/jvm/modifier/inner.lux      |   5 +-
 stdlib/source/lux/io.lux                           |   2 +-
 stdlib/source/lux/locale.lux                       |   2 +-
 stdlib/source/lux/locale/language.lux              |   2 +-
 stdlib/source/lux/locale/territory.lux             |   2 +-
 stdlib/source/lux/macro.lux                        |   2 +-
 stdlib/source/lux/macro/code.lux                   |   2 +-
 stdlib/source/lux/macro/poly.lux                   |   5 +-
 stdlib/source/lux/macro/poly/equivalence.lux       |  15 +-
 stdlib/source/lux/macro/poly/functor.lux           |   5 +-
 stdlib/source/lux/macro/poly/json.lux              |   5 +-
 stdlib/source/lux/macro/syntax.lux                 |   5 +-
 stdlib/source/lux/macro/syntax/common/reader.lux   |   3 +-
 stdlib/source/lux/macro/template.lux               |   3 +-
 stdlib/source/lux/math/infix.lux                   |   3 +-
 stdlib/source/lux/math/logic/fuzzy.lux             |   2 +-
 stdlib/source/lux/math/modular.lux                 |   7 +-
 stdlib/source/lux/math/random.lux                  |   2 +-
 stdlib/source/lux/test.lux                         |   3 +-
 stdlib/source/lux/time/date.lux                    |   5 +-
 stdlib/source/lux/time/day.lux                     |   2 +-
 stdlib/source/lux/time/duration.lux                |   5 +-
 stdlib/source/lux/time/instant.lux                 |   5 +-
 stdlib/source/lux/time/month.lux                   |   2 +-
 stdlib/source/lux/tool/compiler/analysis.lux       |   2 +-
 stdlib/source/lux/tool/compiler/meta/archive.lux   |   5 +-
 .../lux/tool/compiler/meta/archive/signature.lux   |   2 +-
 stdlib/source/lux/tool/compiler/phase.lux          |   5 +-
 .../source/lux/tool/compiler/phase/extension.lux   |   3 +-
 .../lux/tool/compiler/phase/extension/bundle.lux   |   2 +-
 .../source/lux/tool/compiler/phase/generation.lux  |   3 +-
 .../tool/compiler/phase/generation/extension.lux   |   2 +-
 .../lux/tool/compiler/phase/generation/js.lux      |   2 +-
 .../lux/tool/compiler/phase/generation/js/case.lux |   3 +-
 .../phase/generation/js/extension/common.lux       |   2 +-
 .../phase/generation/js/extension/host.lux         |   2 +-
 .../tool/compiler/phase/generation/js/function.lux |   3 +-
 .../lux/tool/compiler/phase/generation/js/loop.lux |   2 +-
 .../tool/compiler/phase/generation/js/runtime.lux  |   3 +-
 .../compiler/phase/generation/js/structure.lux     |   2 +-
 .../lux/tool/compiler/phase/generation/python.lux  |   2 +-
 .../tool/compiler/phase/generation/python/case.lux |   3 +-
 .../phase/generation/python/extension/common.lux   |   2 +-
 .../phase/generation/python/extension/host.lux     |   2 +-
 .../compiler/phase/generation/python/function.lux  |   3 +-
 .../tool/compiler/phase/generation/python/loop.lux |   2 +-
 .../compiler/phase/generation/python/runtime.lux   |   3 +-
 .../compiler/phase/generation/python/structure.lux |   2 +-
 .../lux/tool/compiler/phase/generation/scheme.lux  |   2 +-
 .../compiler/phase/generation/scheme/case.jvm.lux  |   9 +-
 .../generation/scheme/extension/common.jvm.lux     |   3 +-
 .../phase/generation/scheme/function.jvm.lux       |   3 +-
 .../compiler/phase/generation/scheme/loop.jvm.lux  |   2 +-
 .../phase/generation/scheme/runtime.jvm.lux        |   5 +-
 .../phase/generation/scheme/structure.jvm.lux      |   2 +-
 .../lux/tool/compiler/phase/synthesis/case.lux     |   5 +-
 .../lux/tool/compiler/phase/synthesis/function.lux |   3 +-
 .../lux/tool/compiler/phase/synthesis/loop.lux     |   3 +-
 stdlib/source/lux/tool/compiler/reference.lux      |   5 +-
 stdlib/source/lux/tool/compiler/synthesis.lux      |   5 +-
 stdlib/source/lux/type.lux                         |   5 +-
 stdlib/source/lux/type/abstract.lux                |   3 +-
 stdlib/source/lux/type/check.lux                   |   5 +-
 stdlib/source/lux/type/implicit.lux                |   5 +-
 stdlib/source/lux/type/refinement.lux              |   2 +-
 stdlib/source/lux/type/resource.lux                |   5 +-
 stdlib/source/lux/type/unit.lux                    |   5 +-
 stdlib/source/lux/world/binary.lux                 |   5 +-
 stdlib/source/lux/world/file.lux                   |   3 +-
 stdlib/source/lux/world/net/tcp.jvm.lux            |   3 +-
 stdlib/source/lux/world/net/udp.jvm.lux            |   3 +-
 stdlib/source/program/licentia.lux                 |   3 +-
 stdlib/source/program/scriptum.lux                 |   3 +-
 stdlib/source/test/licentia.lux                    |   3 +-
 stdlib/source/test/lux.lux                         |   5 +-
 stdlib/source/test/lux/abstract.lux                |  11 +
 stdlib/source/test/lux/abstract/apply.lux          |  71 ++++++
 stdlib/source/test/lux/abstract/codec.lux          |  26 +++
 stdlib/source/test/lux/abstract/enum.lux           |  27 +++
 stdlib/source/test/lux/abstract/equivalence.lux    |  25 +++
 stdlib/source/test/lux/abstract/fold.lux           |  20 ++
 stdlib/source/test/lux/abstract/functor.lux        |  58 +++++
 stdlib/source/test/lux/abstract/interval.lux       | 248 ++++++++++++++++++++
 stdlib/source/test/lux/abstract/monad.lux          |  58 +++++
 stdlib/source/test/lux/abstract/monoid.lux         |  24 ++
 stdlib/source/test/lux/abstract/number.lux         |  46 ++++
 stdlib/source/test/lux/abstract/order.lux          |  26 +++
 stdlib/source/test/lux/cli.lux                     |   2 +-
 stdlib/source/test/lux/control.lux                 |   2 -
 stdlib/source/test/lux/control/apply.lux           |  72 ------
 stdlib/source/test/lux/control/codec.lux           |  27 ---
 .../source/test/lux/control/concurrency/actor.lux  |   2 +-
 .../source/test/lux/control/concurrency/atom.lux   |   3 +-
 stdlib/source/test/lux/control/concurrency/frp.lux |   2 +-
 .../test/lux/control/concurrency/promise.lux       |   2 +-
 .../test/lux/control/concurrency/semaphore.lux     |   3 +-
 stdlib/source/test/lux/control/concurrency/stm.lux |   2 +-
 stdlib/source/test/lux/control/continuation.lux    |   2 +-
 stdlib/source/test/lux/control/enum.lux            |  28 ---
 stdlib/source/test/lux/control/equivalence.lux     |  26 ---
 stdlib/source/test/lux/control/exception.lux       |   3 +-
 stdlib/source/test/lux/control/fold.lux            |  21 --
 stdlib/source/test/lux/control/functor.lux         |  58 -----
 stdlib/source/test/lux/control/interval.lux        | 249 ---------------------
 stdlib/source/test/lux/control/monad.lux           |  58 -----
 stdlib/source/test/lux/control/monoid.lux          |  25 ---
 stdlib/source/test/lux/control/number.lux          |  47 ----
 stdlib/source/test/lux/control/order.lux           |  27 ---
 stdlib/source/test/lux/control/parser.lux          |   2 +-
 stdlib/source/test/lux/control/pipe.lux            |   2 +-
 stdlib/source/test/lux/control/reader.lux          |   2 +-
 stdlib/source/test/lux/control/region.lux          |   3 +-
 .../source/test/lux/control/security/integrity.lux |   2 +-
 .../source/test/lux/control/security/privacy.lux   |   7 +-
 stdlib/source/test/lux/control/state.lux           |   5 +-
 stdlib/source/test/lux/control/thread.lux          |   2 +-
 stdlib/source/test/lux/control/writer.lux          |   2 +-
 stdlib/source/test/lux/data/bit.lux                |   2 +-
 stdlib/source/test/lux/data/collection/array.lux   |   5 +-
 stdlib/source/test/lux/data/collection/bits.lux    |   2 +-
 .../source/test/lux/data/collection/dictionary.lux |   2 +-
 .../lux/data/collection/dictionary/ordered.lux     |   2 +-
 stdlib/source/test/lux/data/collection/list.lux    |   5 +-
 stdlib/source/test/lux/data/collection/queue.lux   |   2 +-
 .../test/lux/data/collection/queue/priority.lux    |   2 +-
 stdlib/source/test/lux/data/collection/row.lux     |   2 +-
 .../source/test/lux/data/collection/sequence.lux   |   4 +-
 stdlib/source/test/lux/data/collection/set.lux     |   2 +-
 .../test/lux/data/collection/set/ordered.lux       |   2 +-
 stdlib/source/test/lux/data/collection/stack.lux   |   2 +-
 .../source/test/lux/data/collection/tree/rose.lux  |   2 +-
 .../test/lux/data/collection/tree/rose/zipper.lux  |   2 +-
 stdlib/source/test/lux/data/color.lux              |   2 +-
 stdlib/source/test/lux/data/error.lux              |   5 +-
 stdlib/source/test/lux/data/format/json.lux        |   7 +-
 stdlib/source/test/lux/data/format/xml.lux         |   7 +-
 stdlib/source/test/lux/data/identity.lux           |   2 +-
 stdlib/source/test/lux/data/lazy.lux               |   2 +-
 stdlib/source/test/lux/data/maybe.lux              |   5 +-
 stdlib/source/test/lux/data/name.lux               |   5 +-
 stdlib/source/test/lux/data/number/complex.lux     |   2 +-
 stdlib/source/test/lux/data/number/frac.lux        |   2 +-
 stdlib/source/test/lux/data/number/i64.lux         |   2 +-
 stdlib/source/test/lux/data/number/int.lux         |   2 +-
 stdlib/source/test/lux/data/number/nat.lux         |   2 +-
 stdlib/source/test/lux/data/number/ratio.lux       |   2 +-
 stdlib/source/test/lux/data/number/rev.lux         |   2 +-
 stdlib/source/test/lux/data/text.lux               |   5 +-
 stdlib/source/test/lux/data/text/lexer.lux         |   2 +-
 stdlib/source/test/lux/data/text/regex.lux         |   2 +-
 stdlib/source/test/lux/host.jvm.lux                |   2 +-
 stdlib/source/test/lux/host/jvm.jvm.lux            |   2 +-
 stdlib/source/test/lux/io.lux                      |   2 +-
 stdlib/source/test/lux/macro.lux                   |   2 +-
 stdlib/source/test/lux/macro/code.lux              |   2 +-
 stdlib/source/test/lux/macro/poly/equivalence.lux  |   4 +-
 stdlib/source/test/lux/macro/poly/functor.lux      |   2 +-
 stdlib/source/test/lux/macro/poly/json.lux         |   7 +-
 stdlib/source/test/lux/macro/syntax.lux            |   5 +-
 stdlib/source/test/lux/math.lux                    |   3 +-
 stdlib/source/test/lux/math/infix.lux              |   2 +-
 stdlib/source/test/lux/math/logic/continuous.lux   |   2 +-
 stdlib/source/test/lux/math/logic/fuzzy.lux        |   2 +-
 stdlib/source/test/lux/math/modular.lux            |   2 +-
 stdlib/source/test/lux/time/date.lux               |   3 +-
 stdlib/source/test/lux/time/day.lux                |   2 +-
 stdlib/source/test/lux/time/duration.lux           |   2 +-
 stdlib/source/test/lux/time/instant.lux            |   5 +-
 stdlib/source/test/lux/time/month.lux              |   2 +-
 stdlib/source/test/lux/type.lux                    |   2 +-
 stdlib/source/test/lux/type/check.lux              |   3 +-
 stdlib/source/test/lux/type/dynamic.lux            |   2 +-
 stdlib/source/test/lux/type/implicit.lux           |   4 +-
 stdlib/source/test/lux/type/resource.lux           |   2 +-
 stdlib/source/test/lux/world/binary.lux            |   3 +-
 stdlib/source/test/lux/world/file.lux              |   2 +-
 stdlib/source/test/lux/world/net/tcp.lux           |   2 +-
 stdlib/source/test/lux/world/net/udp.lux           |   2 +-
 294 files changed, 2018 insertions(+), 1897 deletions(-)
 create mode 100644 stdlib/source/lux/abstract/algebra.lux
 create mode 100644 stdlib/source/lux/abstract/apply.lux
 create mode 100644 stdlib/source/lux/abstract/codec.lux
 create mode 100644 stdlib/source/lux/abstract/comonad.lux
 create mode 100644 stdlib/source/lux/abstract/enum.lux
 create mode 100644 stdlib/source/lux/abstract/equivalence.lux
 create mode 100644 stdlib/source/lux/abstract/fold.lux
 create mode 100644 stdlib/source/lux/abstract/functor.lux
 create mode 100644 stdlib/source/lux/abstract/hash.lux
 create mode 100644 stdlib/source/lux/abstract/interval.lux
 create mode 100644 stdlib/source/lux/abstract/monad.lux
 create mode 100644 stdlib/source/lux/abstract/monad/free.lux
 create mode 100644 stdlib/source/lux/abstract/monad/indexed.lux
 create mode 100644 stdlib/source/lux/abstract/monoid.lux
 create mode 100644 stdlib/source/lux/abstract/number.lux
 create mode 100644 stdlib/source/lux/abstract/order.lux
 create mode 100644 stdlib/source/lux/abstract/predicate.lux
 delete mode 100644 stdlib/source/lux/control/algebra.lux
 delete mode 100644 stdlib/source/lux/control/apply.lux
 delete mode 100644 stdlib/source/lux/control/codec.lux
 delete mode 100644 stdlib/source/lux/control/comonad.lux
 delete mode 100644 stdlib/source/lux/control/enum.lux
 delete mode 100644 stdlib/source/lux/control/equivalence.lux
 delete mode 100644 stdlib/source/lux/control/fold.lux
 delete mode 100644 stdlib/source/lux/control/functor.lux
 delete mode 100644 stdlib/source/lux/control/hash.lux
 delete mode 100644 stdlib/source/lux/control/interval.lux
 delete mode 100644 stdlib/source/lux/control/monad.lux
 delete mode 100644 stdlib/source/lux/control/monad/free.lux
 delete mode 100644 stdlib/source/lux/control/monad/indexed.lux
 delete mode 100644 stdlib/source/lux/control/monoid.lux
 delete mode 100644 stdlib/source/lux/control/number.lux
 delete mode 100644 stdlib/source/lux/control/order.lux
 delete mode 100644 stdlib/source/lux/control/predicate.lux
 create mode 100644 stdlib/source/test/lux/abstract.lux
 create mode 100644 stdlib/source/test/lux/abstract/apply.lux
 create mode 100644 stdlib/source/test/lux/abstract/codec.lux
 create mode 100644 stdlib/source/test/lux/abstract/enum.lux
 create mode 100644 stdlib/source/test/lux/abstract/equivalence.lux
 create mode 100644 stdlib/source/test/lux/abstract/fold.lux
 create mode 100644 stdlib/source/test/lux/abstract/functor.lux
 create mode 100644 stdlib/source/test/lux/abstract/interval.lux
 create mode 100644 stdlib/source/test/lux/abstract/monad.lux
 create mode 100644 stdlib/source/test/lux/abstract/monoid.lux
 create mode 100644 stdlib/source/test/lux/abstract/number.lux
 create mode 100644 stdlib/source/test/lux/abstract/order.lux
 delete mode 100644 stdlib/source/test/lux/control/apply.lux
 delete mode 100644 stdlib/source/test/lux/control/codec.lux
 delete mode 100644 stdlib/source/test/lux/control/enum.lux
 delete mode 100644 stdlib/source/test/lux/control/equivalence.lux
 delete mode 100644 stdlib/source/test/lux/control/fold.lux
 delete mode 100644 stdlib/source/test/lux/control/functor.lux
 delete mode 100644 stdlib/source/test/lux/control/interval.lux
 delete mode 100644 stdlib/source/test/lux/control/monad.lux
 delete mode 100644 stdlib/source/test/lux/control/monoid.lux
 delete mode 100644 stdlib/source/test/lux/control/number.lux
 delete mode 100644 stdlib/source/test/lux/control/order.lux

(limited to 'stdlib/source')

diff --git a/stdlib/source/lux.lux b/stdlib/source/lux.lux
index 45b190c82..1a3d71480 100644
--- a/stdlib/source/lux.lux
+++ b/stdlib/source/lux.lux
@@ -3958,7 +3958,7 @@
       #None
       (fail "Wrong syntax for structure:"))))
 
-(def: (identity x) (All [a] (-> a a)) x)
+(def: (function@identity x) (All [a] (-> a a)) x)
 
 (macro: #export (type: tokens)
   {#.doc (text$ ($_ "lux text concat"
@@ -5289,8 +5289,8 @@
              <open>
              parts-text
              <close>)]))
-    ([#Form   "(" ")" ..identity]
-     [#Tuple  "[" "]" ..identity]
+    ([#Form   "(" ")" ..function@identity]
+     [#Tuple  "[" "]" ..function@identity]
      [#Record "{" "}" rejoin-all-pairs])
 
     [new-cursor (#Rev value)]
diff --git a/stdlib/source/lux/abstract/algebra.lux b/stdlib/source/lux/abstract/algebra.lux
new file mode 100644
index 000000000..2813ed0e7
--- /dev/null
+++ b/stdlib/source/lux/abstract/algebra.lux
@@ -0,0 +1,17 @@
+(.module:
+  [lux #*
+   [control
+    functor]])
+
+## Types
+(type: #export (Algebra f a)
+  (-> (f a) a))
+
+(type: #export (CoAlgebra f a)
+  (-> a (f a)))
+
+(type: #export (RAlgebra f a)
+  (-> (f (& (Fix f) a)) a))
+
+(type: #export (RCoAlgebra f a)
+  (-> a (f (| (Fix f) a))))
diff --git a/stdlib/source/lux/abstract/apply.lux b/stdlib/source/lux/abstract/apply.lux
new file mode 100644
index 000000000..5eb42b63d
--- /dev/null
+++ b/stdlib/source/lux/abstract/apply.lux
@@ -0,0 +1,36 @@
+(.module:
+  lux
+  [//
+   ["." functor (#+ Functor)]
+   [monad (#+ Monad)]])
+
+(signature: #export (Apply f)
+  {#.doc "Applicative functors."}
+  (: (Functor f)
+     &functor)
+  (: (All [a b]
+       (-> (f (-> a b)) (f a) (f b)))
+     apply))
+
+(structure: #export (compose f-monad f-apply g-apply)
+  {#.doc "Applicative functor composition."}
+  (All [F G]
+    (-> (Monad F) (Apply F) (Apply G)
+        ## TODO: Replace (All [a] (F (G a))) with (functor.Then F G)
+        (Apply (All [a] (F (G a))))))
+  
+  (def: &functor (functor.compose (get@ #&functor f-apply) (get@ #&functor g-apply)))
+  
+  (def: (apply fgf fgx)
+    ## TODO: Switch from this version to the one below (in comments) ASAP.
+    (let [fgf' (:: f-apply apply
+                   (:: f-monad wrap (:: g-apply apply))
+                   fgf)]
+      (:: f-apply apply fgf' fgx))
+    ## (let [applyF (:: f-apply apply)
+    ##       applyG (:: g-apply apply)]
+    ##   ($_ applyF
+    ##       (:: f-monad wrap applyG)
+    ##       fgf
+    ##       fgx))
+    ))
diff --git a/stdlib/source/lux/abstract/codec.lux b/stdlib/source/lux/abstract/codec.lux
new file mode 100644
index 000000000..abe80ba4a
--- /dev/null
+++ b/stdlib/source/lux/abstract/codec.lux
@@ -0,0 +1,27 @@
+(.module:
+  [lux #*
+   [data
+    ["." error (#+ Error)]]]
+  [//
+   monad])
+
+(signature: #export (Codec m a)
+  {#.doc "A way to move back-and-forth between a type and an alternative representation for it."}
+  (: (-> a m)
+     encode)
+  (: (-> m (Error a))
+     decode))
+
+(structure: #export (compose cb-codec ba-codec)
+  {#.doc "Codec composition."}
+  (All [a b c]
+    (-> (Codec c b) (Codec b a)
+        (Codec c a)))
+  (def: encode
+    (|>> (:: ba-codec encode)
+         (:: cb-codec encode)))
+
+  (def: (decode cy)
+    (do error.monad
+      [by (:: cb-codec decode cy)]
+      (:: ba-codec decode by))))
diff --git a/stdlib/source/lux/abstract/comonad.lux b/stdlib/source/lux/abstract/comonad.lux
new file mode 100644
index 000000000..1d6ac49e5
--- /dev/null
+++ b/stdlib/source/lux/abstract/comonad.lux
@@ -0,0 +1,62 @@
+(.module:
+  [lux #*
+   [data
+    [collection
+     ["." list ("#;." fold)]]]]
+  [//
+   ["." functor (#+ Functor)]])
+
+(signature: #export (CoMonad w)
+  {#.doc (doc "CoMonads are the opposite/complement to monads."
+              "CoMonadic structures are often infinite in size and built upon lazily-evaluated functions.")}
+  (: (Functor w)
+     &functor)
+  (: (All [a]
+       (-> (w a) a))
+     unwrap)
+  (: (All [a]
+       (-> (w a) (w (w a))))
+     split))
+
+(type: #export (CoFree F a)
+  {#.doc "The CoFree CoMonad."}
+  [a (F (CoFree F a))])
+
+(def: _cursor Cursor ["" 0 0])
+
+(macro: #export (be tokens state)
+  {#.doc (doc "A co-monadic parallel to the 'do' macro."
+              (let [square (function (_ n) (i/* n n))]
+                (be comonad
+                  [inputs (iterate inc +2)]
+                  (square (head inputs)))))}
+  (case tokens
+    (#.Cons comonad (#.Cons [_ (#.Tuple bindings)] (#.Cons body #.Nil)))
+    (if (|> bindings list.size (n/% 2) (n/= 0))
+      (let [g!_ (: Code [_cursor (#.Identifier ["" " _ "])])
+            g!map (: Code [_cursor (#.Identifier ["" " map "])])
+            g!split (: Code [_cursor (#.Identifier ["" " split "])])
+            body' (list;fold (: (-> [Code Code] Code Code)
+                                (function (_ binding body')
+                                  (let [[var value] binding]
+                                    (case var
+                                      [_ (#.Tag ["" "let"])]
+                                      (` (let (~ value) (~ body')))
+
+                                      _
+                                      (` (|> (~ value) (~ g!split) ((~ g!map) (function ((~ g!_) (~ var)) (~ body')))))
+                                      ))))
+                             body
+                             (list.reverse (list.as-pairs bindings)))]
+        (#.Right [state (#.Cons (` ({(~' @)
+                                     ({{#&functor {#functor.map (~ g!map)}
+                                        #unwrap (~' unwrap)
+                                        #split (~ g!split)}
+                                       (~ body')}
+                                      (~' @))}
+                                    (~ comonad)))
+                                #.Nil)]))
+      (#.Left "'be' bindings must have an even number of parts."))
+
+    _
+    (#.Left "Wrong syntax for 'be'")))
diff --git a/stdlib/source/lux/abstract/enum.lux b/stdlib/source/lux/abstract/enum.lux
new file mode 100644
index 000000000..5bbb7df38
--- /dev/null
+++ b/stdlib/source/lux/abstract/enum.lux
@@ -0,0 +1,21 @@
+(.module:
+  [lux #*]
+  [//
+   ["." order]])
+
+(signature: #export (Enum e)
+  {#.doc "Enumerable types, with a notion of moving forward and backwards through a type's instances."}
+  (: (order.Order e) &order)
+  (: (-> e e) succ)
+  (: (-> e e) pred))
+
+(def: (range' <= succ from to)
+  (All [a] (-> (-> a a Bit) (-> a a) a a (List a)))
+  (if (<= to from)
+    (#.Cons from (range' <= succ (succ from) to))
+    #.Nil))
+
+(def: #export (range (^open ".") from to)
+  {#.doc "An inclusive [from, to] range of values."}
+  (All [a] (-> (Enum a) a a (List a)))
+  (range' <= succ from to))
diff --git a/stdlib/source/lux/abstract/equivalence.lux b/stdlib/source/lux/abstract/equivalence.lux
new file mode 100644
index 000000000..b773505de
--- /dev/null
+++ b/stdlib/source/lux/abstract/equivalence.lux
@@ -0,0 +1,42 @@
+(.module:
+  [lux #*]
+  [//
+   [functor (#+ Contravariant)]])
+
+(signature: #export (Equivalence a)
+  {#.doc "Equivalence for a type's instances."}
+  (: (-> a a Bit)
+     =))
+
+(def: #export (product left right)
+  (All [l r] (-> (Equivalence l) (Equivalence r) (Equivalence [l r])))
+  (structure
+   (def: (= [a b] [x y])
+     (and (:: left = a x)
+          (:: right = b y)))))
+
+(def: #export (sum left right)
+  (All [l r] (-> (Equivalence l) (Equivalence r) (Equivalence (| l r))))
+  (structure
+   (def: (= a|b x|y)
+     (case [a|b x|y]
+       [(0 a) (0 x)]
+       (:: left = a x)
+
+       [(1 b) (1 y)]
+       (:: right = b y)
+
+       _
+       #0))))
+
+(def: #export (rec sub)
+  (All [a] (-> (-> (Equivalence a) (Equivalence a)) (Equivalence a)))
+  (structure
+   (def: (= left right)
+     (sub (rec sub) left right))))
+
+(structure: #export contravariant (Contravariant Equivalence)
+  (def: (map-1 f equivalence)
+    (structure
+     (def: (= reference sample)
+       (:: equivalence = (f reference) (f sample))))))
diff --git a/stdlib/source/lux/abstract/fold.lux b/stdlib/source/lux/abstract/fold.lux
new file mode 100644
index 000000000..504f41f58
--- /dev/null
+++ b/stdlib/source/lux/abstract/fold.lux
@@ -0,0 +1,18 @@
+(.module:
+  [lux #*]
+  [//
+   [monoid (#+ Monoid)]])
+
+(signature: #export (Fold F)
+  {#.doc "Iterate over a structure's values to build a summary value."}
+  (: (All [a b]
+       (-> (-> b a a) a (F b) a))
+     fold))
+
+(def: #export (with-monoid monoid fold value)
+  (All [F a]
+    (-> (Monoid a) (Fold F) (F a) a))
+  (let [(^open "monoid;.") monoid]
+    (fold monoid;compose
+          monoid;identity
+          value)))
diff --git a/stdlib/source/lux/abstract/functor.lux b/stdlib/source/lux/abstract/functor.lux
new file mode 100644
index 000000000..1ade0a45b
--- /dev/null
+++ b/stdlib/source/lux/abstract/functor.lux
@@ -0,0 +1,32 @@
+(.module: lux)
+
+(signature: #export (Functor f)
+  (: (All [a b]
+       (-> (-> a b)
+           (-> (f a) (f b))))
+     map))
+
+(type: #export (Fix f)
+  (f (Fix f)))
+
+(type: #export (And f g)
+  (All [a] (& (f a) (g a))))
+
+(type: #export (Or f g)
+  (All [a] (| (f a) (g a))))
+
+(type: #export (Then f g)
+  (All [a] (f (g a))))
+
+(def: #export (compose f-functor g-functor)
+  {#.doc "Functor composition."}
+  (All [F G] (-> (Functor F) (Functor G) (Functor (..Then F G))))
+  (structure
+   (def: (map f fga)
+     (:: f-functor map (:: g-functor map f) fga))))
+
+(signature: #export (Contravariant f)
+  (: (All [a b]
+       (-> (-> b a)
+           (-> (f a) (f b))))
+     map-1))
diff --git a/stdlib/source/lux/abstract/hash.lux b/stdlib/source/lux/abstract/hash.lux
new file mode 100644
index 000000000..d2dee3bcb
--- /dev/null
+++ b/stdlib/source/lux/abstract/hash.lux
@@ -0,0 +1,13 @@
+(.module:
+  lux
+  [//
+   [equivalence (#+ Equivalence)]])
+
+## [Signatures]
+(signature: #export (Hash a)
+  {#.doc (doc "A way to produce hash-codes for a type's instances."
+              "A necessity when working with some data-structures, such as dictionaries or sets.")}
+  (: (Equivalence a)
+     &equivalence)
+  (: (-> a Nat)
+     hash))
diff --git a/stdlib/source/lux/abstract/interval.lux b/stdlib/source/lux/abstract/interval.lux
new file mode 100644
index 000000000..efb131843
--- /dev/null
+++ b/stdlib/source/lux/abstract/interval.lux
@@ -0,0 +1,184 @@
+(.module:
+  [lux #*]
+  [//
+   [equivalence (#+ Equivalence)]
+   ["." order]
+   [enum (#+ Enum)]])
+
+(signature: #export (Interval a)
+  {#.doc "A representation of top and bottom boundaries for an ordered type."}
+  (: (Enum a)
+     &enum)
+
+  (: a
+     bottom)
+
+  (: a
+     top))
+
+(def: #export (between enum bottom top)
+  (All [a] (-> (Enum a) a a (Interval a)))
+  (structure (def: &enum enum)
+             (def: bottom bottom)
+             (def: top top)))
+
+(def: #export (singleton enum elem)
+  (All [a] (-> (Enum a) a (Interval a)))
+  (structure (def: &enum enum)
+             (def: bottom elem)
+             (def: top elem)))
+
+(template [<name> <comp>]
+  [(def: #export (<name> interval)
+     (All [a] (-> (Interval a) Bit))
+     (let [(^open ".") interval]
+       (<comp> bottom top)))]
+
+  [inner?     >]
+  [outer?     <]
+  [singleton? =]
+  )
+
+(def: #export (within? interval elem)
+  (All [a] (-> (Interval a) a Bit))
+  (let [(^open ".") interval]
+    (cond (inner? interval)
+          (and (>= bottom elem)
+               (<= top elem))
+          
+          (outer? interval)
+          (or (>= bottom elem)
+              (<= top elem))
+          
+          ## singleton
+          (and (= bottom elem)
+               (= top elem)))))
+
+(template [<name> <limit>]
+  [(def: #export (<name> elem interval)
+     (All [a] (-> a (Interval a) Bit))
+     (let [(^open ".") interval]
+       (= <limit> elem)))]
+
+  [starts-with? bottom]
+  [ends-with?   top]
+  )
+
+(def: #export (borders? interval elem)
+  (All [a] (-> (Interval a) a Bit))
+  (or (starts-with? elem interval)
+      (ends-with? elem interval)))
+
+(def: #export (union left right)
+  (All [a] (-> (Interval a) (Interval a) (Interval a)))
+  (structure (def: &enum (get@ #&enum right))
+             (def: bottom (order.min (:: right &order) (:: left bottom) (:: right bottom)))
+             (def: top (order.max (:: right &order) (:: left top) (:: right top)))))
+
+(def: #export (intersection left right)
+  (All [a] (-> (Interval a) (Interval a) (Interval a)))
+  (structure (def: &enum (get@ #&enum right))
+             (def: bottom (order.max (:: right &order) (:: left bottom) (:: right bottom)))
+             (def: top (order.min (:: right &order) (:: left top) (:: right top)))))
+
+(def: #export (complement interval)
+  (All [a] (-> (Interval a) (Interval a)))
+  (let [(^open ".") interval]
+    (structure (def: &enum (get@ #&enum interval))
+               (def: bottom (succ top))
+               (def: top (pred bottom)))))
+
+(def: #export (precedes? reference sample)
+  (All [a] (-> (Interval a) (Interval a) Bit))
+  (let [(^open ".") reference
+        limit (:: reference bottom)]
+    (and (< limit (:: sample bottom))
+         (< limit (:: sample top)))))
+
+(def: #export (succeeds? reference sample)
+  (All [a] (-> (Interval a) (Interval a) Bit))
+  (precedes? sample reference))
+
+(def: #export (meets? reference sample)
+  (All [a] (-> (Interval a) (Interval a) Bit))
+  (let [(^open ".") reference
+        limit (:: reference bottom)]
+    (and (<= limit (:: sample bottom))
+         (= limit (:: sample top)))))
+
+(def: #export (touches? reference sample)
+  (All [a] (-> (Interval a) (Interval a) Bit))
+  (or (meets? reference sample)
+      (meets? sample reference)))
+
+(template [<name> <eq-side> <ineq> <ineq-side>]
+  [(def: #export (<name> reference sample)
+     (All [a] (-> (Interval a) (Interval a) Bit))
+     (let [(^open ".") reference]
+       (and (=      (:: reference <eq-side>)   (:: sample <eq-side>))
+            (<ineq> (:: reference <ineq-side>) (:: sample <ineq-side>)))))]
+
+  [starts?   bottom <= top]
+  [finishes? top    >= bottom]
+  )
+
+(template [<name> <comp>]
+  [(def: #export (<name> reference sample)
+     (All [a] (-> a (Interval a) Bit))
+     (let [(^open ".") sample]
+       (and (<comp> reference bottom)
+            (<comp> reference top))))]
+
+  [before? <]
+  [after?  >]
+  )
+
+(structure: #export equivalence (All [a] (Equivalence (Interval a)))
+  (def: (= reference sample)
+    (let [(^open "_;.") reference]
+      (and (_;= _;bottom (:: sample bottom))
+           (_;= _;top (:: sample top))))))
+
+(def: #export (nested? reference sample)
+  (All [a] (-> (Interval a) (Interval a) Bit))
+  (cond (or (singleton? sample)
+            (and (inner? reference) (inner? sample))
+            (and (outer? reference) (outer? sample)))
+        (let [(^open ".") reference]
+          (and (>= (:: reference bottom) (:: sample bottom))
+               (<= (:: reference top) (:: sample top))))
+
+        (or (singleton? reference)
+            (and (inner? reference) (outer? sample)))
+        #0
+
+        ## (and (outer? reference) (inner? sample))
+        (let [(^open ".") reference]
+          (or (and (>= (:: reference bottom) (:: sample bottom))
+                   (> (:: reference bottom) (:: sample top)))
+              (and (< (:: reference top) (:: sample bottom))
+                   (<= (:: reference top) (:: sample top)))))
+        ))
+
+(def: #export (overlaps? reference sample)
+  (All [a] (-> (Interval a) (Interval a) Bit))
+  (let [(^open ".") reference]
+    (and (not (:: ..equivalence = reference sample))
+         (cond (singleton? sample)
+               #0
+
+               (singleton? reference)
+               (nested? sample reference)
+
+               (or (and (inner? sample) (outer? reference))
+                   (and (outer? sample) (inner? reference)))
+               (or (>= (:: reference bottom) (:: sample top))
+                   (<= (:: reference top) (:: sample bottom)))
+
+               ## both inner
+               (inner? sample)
+               (inner? (intersection reference sample))
+
+               ## both outer
+               (not (nested? reference sample))
+               ))))
diff --git a/stdlib/source/lux/abstract/monad.lux b/stdlib/source/lux/abstract/monad.lux
new file mode 100644
index 000000000..0e509c64e
--- /dev/null
+++ b/stdlib/source/lux/abstract/monad.lux
@@ -0,0 +1,168 @@
+(.module:
+  [lux #*]
+  [//
+   ["." functor (#+ Functor)]])
+
+(def: (list;fold f init xs)
+  (All [a b]
+    (-> (-> b a a) a (List b) a)) 
+  (case xs
+    #.Nil
+    init
+
+    (#.Cons x xs')
+    (list;fold f (f x init) xs')))
+
+(def: (list;size xs)
+  (All [a] (-> (List a) Nat))
+  (loop [counter 0
+         xs xs]
+    (case xs
+      #.Nil
+      counter
+
+      (#.Cons _ xs')
+      (recur (inc counter) xs'))))
+
+(def: (reverse xs)
+  (All [a]
+    (-> (List a) (List a)))
+  (list;fold (function (_ head tail) (#.Cons head tail))
+             #.Nil
+             xs))
+
+(def: (as-pairs xs)
+  (All [a] (-> (List a) (List [a a])))
+  (case xs
+    (#.Cons x1 (#.Cons x2 xs'))
+    (#.Cons [x1 x2] (as-pairs xs'))
+
+    _
+    #.Nil))
+
+(signature: #export (Monad m)
+  (: (Functor m)
+     &functor)
+  (: (All [a]
+       (-> a (m a)))
+     wrap)
+  (: (All [a]
+       (-> (m (m a)) (m a)))
+     join))
+
+(def: _cursor Cursor ["" 0 0])
+
+(macro: #export (do tokens state)
+  {#.doc (doc "Macro for easy concatenation of monadic operations."
+              (do monad
+                [y (f1 x)
+                 z (f2 z)]
+                (wrap (f3 z))))}
+  (case tokens
+    (#.Cons monad (#.Cons [_ (#.Tuple bindings)] (#.Cons body #.Nil)))
+    (if (|> bindings list;size (n/% 2) (n/= 0))
+      (let [g!_ (: Code [_cursor (#.Identifier ["" " _ "])])
+            g!map (: Code [_cursor (#.Identifier ["" " map "])])
+            g!join (: Code [_cursor (#.Identifier ["" " join "])])
+            body' (list;fold (: (-> [Code Code] Code Code)
+                                (function (_ binding body')
+                                  (let [[var value] binding]
+                                    (case var
+                                      [_ (#.Tag ["" "let"])]
+                                      (` (let (~ value) (~ body')))
+
+                                      _
+                                      (` (|> (~ value) ((~ g!map) (function ((~ g!_) (~ var)) (~ body'))) (~ g!join)))
+                                      ))))
+                             body
+                             (reverse (as-pairs bindings)))]
+        (#.Right [state (#.Cons (` ({(~' @)
+                                     ({{#..&functor {#functor.map (~ g!map)}
+                                        #..wrap (~' wrap)
+                                        #..join (~ g!join)}
+                                       (~ body')}
+                                      (~' @))}
+                                    (~ monad)))
+                                #.Nil)]))
+      (#.Left "'do' bindings must have an even number of parts."))
+
+    _
+    (#.Left "Wrong syntax for 'do'")))
+
+(def: #export (seq monad)
+  {#.doc "Run all the monadic values in the list and produce a list of the base values."}
+  (All [M a]
+    (-> (Monad M) (List (M a))
+        (M (List a))))
+  (let [(^open "!;.") monad]
+    (function (recur xs)
+      (case xs
+        #.Nil
+        (!;wrap #.Nil)
+        
+        (#.Cons x xs')
+        (|> x
+            (!;map (function (_ _x)
+                     (!;map (|>> (#.Cons _x)) (recur xs'))))
+            !;join)))))
+
+(def: #export (map monad f)
+  {#.doc "Apply a monadic function to all values in a list."}
+  (All [M a b]
+    (-> (Monad M) (-> a (M b)) (List a)
+        (M (List b))))
+  (let [(^open "!;.") monad]
+    (function (recur xs)
+      (case xs
+        #.Nil
+        (!;wrap #.Nil)
+        
+        (#.Cons x xs')
+        (|> (f x)
+            (!;map (function (_ _x)
+                     (!;map (|>> (#.Cons _x)) (recur xs'))))
+            !;join)))))
+
+(def: #export (filter Monad<!> f)
+  {#.doc "Filter the values in a list with a monadic function."}
+  (All [! a b]
+    (-> (Monad !) (-> a (! Bit)) (List a)
+        (! (List a))))
+  (let [(^open "!;.") Monad<!>]
+    (function (recur xs)
+      (case xs
+        #.Nil
+        (!;wrap #.Nil)
+        
+        (#.Cons head xs')
+        (|> (f head)
+            (!;map (function (_ verdict)
+                     (!;map (function (_ tail)
+                              (if verdict
+                                (#.Cons head tail)
+                                tail))
+                            (recur xs'))))
+            !;join)))))
+
+(def: #export (fold monad f init xs)
+  {#.doc "Fold a list with a monadic function."}
+  (All [M a b]
+    (-> (Monad M) (-> b a (M a)) a (List b)
+        (M a)))
+  (case xs
+    #.Nil
+    (:: monad wrap init)
+
+    (#.Cons x xs')
+    (do monad
+      [init' (f x init)]
+      (fold monad f init' xs'))))
+
+(def: #export (lift monad f)
+  {#.doc "Lift a normal function into the space of monads."}
+  (All [M a b]
+    (-> (Monad M) (-> a b) (-> (M a) (M b))))
+  (function (_ ma)
+    (do monad
+      [a ma]
+      (wrap (f a)))))
diff --git a/stdlib/source/lux/abstract/monad/free.lux b/stdlib/source/lux/abstract/monad/free.lux
new file mode 100644
index 000000000..214261450
--- /dev/null
+++ b/stdlib/source/lux/abstract/monad/free.lux
@@ -0,0 +1,67 @@
+(.module:
+  lux
+  [///
+   [functor (#+ Functor)]
+   [apply (#+ Apply)]
+   [monad (#+ Monad)]])
+
+(type: #export (Free F a)
+  {#.doc "The Free Monad."}
+  (#Pure a)
+  (#Effect (F (Free F a))))
+
+(structure: #export (functor dsl)
+  (All [F] (-> (Functor F) (Functor (Free F))))
+  
+  (def: (map f ea)
+    (case ea
+      (#Pure a)
+      (#Pure (f a))
+      
+      (#Effect value)
+      (#Effect (:: dsl map (map f) value)))))
+
+(structure: #export (apply dsl)
+  (All [F] (-> (Functor F) (Apply (Free F))))
+  
+  (def: &functor (..functor dsl))
+
+  (def: (apply ef ea)
+    (case [ef ea]
+      [(#Pure f) (#Pure a)]
+      (#Pure (f a))
+
+      [(#Pure f) (#Effect fa)]
+      (#Effect (:: dsl map
+                   (:: (..functor dsl) map f)
+                   fa))
+
+      [(#Effect ff) _]
+      (#Effect (:: dsl map
+                   (function (_ f) (apply f ea))
+                   ff))
+      )))
+
+(structure: #export (monad dsl)
+  (All [F] (-> (Functor F) (Monad (Free F))))
+
+  (def: &functor (..functor dsl))
+
+  (def: (wrap a)
+    (#Pure a))
+
+  (def: (join efefa)
+    (case efefa
+      (#Pure efa)
+      (case efa
+        (#Pure a)
+        (#Pure a)
+
+        (#Effect fa)
+        (#Effect fa))
+      
+      (#Effect fefa)
+      (#Effect (:: dsl map
+                   (:: (monad dsl) join)
+                   fefa))
+      )))
diff --git a/stdlib/source/lux/abstract/monad/indexed.lux b/stdlib/source/lux/abstract/monad/indexed.lux
new file mode 100644
index 000000000..57a18c109
--- /dev/null
+++ b/stdlib/source/lux/abstract/monad/indexed.lux
@@ -0,0 +1,64 @@
+(.module:
+  [lux #*
+   [control
+    [monad]
+    ["p" parser]]
+   [data
+    [collection
+     ["." list ("#;." functor fold)]]]
+   ["." macro
+    ["s" syntax (#+ Syntax syntax:)]]])
+
+(signature: #export (IxMonad m)
+  (: (All [p a]
+       (-> a (m p p a)))
+     wrap)
+
+  (: (All [ii it io vi vo]
+       (-> (-> vi (m it io vo))
+           (m ii it vi)
+           (m ii io vo)))
+     bind))
+
+(type: Binding [Code Code])
+
+(def: binding
+  (Syntax Binding)
+  (p.and s.any s.any))
+
+(type: Context
+  (#Let (List Binding))
+  (#Bind Binding))
+
+(def: context
+  (Syntax Context)
+  (p.or (p.after (s.this (' #let))
+                 (s.tuple (p.some binding)))
+        binding))
+
+(def: (pair-list [binding value])
+  (All [a] (-> [a a] (List a)))
+  (list binding value))
+
+(syntax: #export (do monad
+                   {context (s.tuple (p.some context))}
+                   expression)
+  (macro.with-gensyms [g!_ g!bind]
+    (wrap (list (` (let [(~' @) (~ monad)
+                         {#..wrap (~' wrap)
+                          #..bind (~ g!bind)} (~' @)]
+                     (~ (list;fold (function (_ context next)
+                                     (case context
+                                       (#Let bindings)
+                                       (` (let [(~+ (|> bindings
+                                                        (list;map pair-list)
+                                                        list.concat))]
+                                            (~ next)))
+                                       
+                                       (#Bind [binding value])
+                                       (` ((~ g!bind)
+                                           (.function ((~ g!_) (~ binding))
+                                             (~ next))
+                                           (~ value)))))
+                                   expression
+                                   (list.reverse context)))))))))
diff --git a/stdlib/source/lux/abstract/monoid.lux b/stdlib/source/lux/abstract/monoid.lux
new file mode 100644
index 000000000..33d082020
--- /dev/null
+++ b/stdlib/source/lux/abstract/monoid.lux
@@ -0,0 +1,19 @@
+(.module:
+  [lux #*])
+
+(signature: #export (Monoid a)
+  {#.doc (doc "A way to compose values."
+              "Includes an identity value which does not alter any other value when combined with.")}
+  (: a
+     identity)
+  (: (-> a a a)
+     compose))
+
+(def: #export (compose Monoid<l> Monoid<r>)
+  (All [l r] (-> (Monoid l) (Monoid r) (Monoid [l r])))
+  (structure (def: identity
+               [(:: Monoid<l> identity) (:: Monoid<r> identity)])
+             
+             (def: (compose [lL rL] [lR rR])
+               [(:: Monoid<l> compose lL lR)
+                (:: Monoid<r> compose rL rR)])))
diff --git a/stdlib/source/lux/abstract/number.lux b/stdlib/source/lux/abstract/number.lux
new file mode 100644
index 000000000..b3a314ba5
--- /dev/null
+++ b/stdlib/source/lux/abstract/number.lux
@@ -0,0 +1,14 @@
+(.module:
+  lux)
+
+(`` (signature: #export (Number n)
+      {#.doc "Everything that should be expected of a number type."}
+
+      (~~ (template [<name>]
+            [(: (-> n n n) <name>)]
+            [+] [-] [*] [/] [%]))
+
+      (~~ (template [<name>]
+            [(: (-> n n) <name>)]
+            [negate] [signum] [abs]))
+      ))
diff --git a/stdlib/source/lux/abstract/order.lux b/stdlib/source/lux/abstract/order.lux
new file mode 100644
index 000000000..85b33fa18
--- /dev/null
+++ b/stdlib/source/lux/abstract/order.lux
@@ -0,0 +1,59 @@
+(.module:
+  [lux #*
+   function]
+  [//
+   [functor (#+ Contravariant)]
+   ["." equivalence (#+ Equivalence)]])
+
+(`` (signature: #export (Order a)
+      {#.doc "A signature for types that possess some sense of ordering among their elements."}
+      
+      (: (Equivalence a)
+         &equivalence)
+      
+      (~~ (template [<name>]
+            [(: (-> a a Bit) <name>)]
+
+            [<] [<=] [>] [>=]
+            ))
+      ))
+
+(def: #export (order equivalence <)
+  (All [a]
+    (-> (Equivalence a) (-> a a Bit) (Order a)))
+  (let [> (flip <)]
+    (structure (def: &equivalence equivalence)
+               
+               (def: < <)
+               
+               (def: (<= test subject)
+                 (or (< test subject)
+                     (:: equivalence = test subject)))
+               
+               (def: > >)
+               
+               (def: (>= test subject)
+                 (or (> test subject)
+                     (:: equivalence = test subject))))))
+
+(template [<name> <op>]
+  [(def: #export (<name> order x y)
+     (All [a]
+       (-> (Order a) a a a))
+     (if (:: order <op> y x) x y))]
+
+  [min <]
+  [max >]
+  )
+
+(`` (structure: #export contravariant (Contravariant Order)
+      (def: (map-1 f order)
+        (structure
+         (def: &equivalence (:: equivalence.contravariant map-1 f (:: order &equivalence)))
+         
+         (~~ (template [<name>]
+               [(def: (<name> reference sample)
+                  (:: order <name> (f reference) (f sample)))]
+
+               [<] [<=] [>] [>=]
+               ))))))
diff --git a/stdlib/source/lux/abstract/predicate.lux b/stdlib/source/lux/abstract/predicate.lux
new file mode 100644
index 000000000..faa1859b9
--- /dev/null
+++ b/stdlib/source/lux/abstract/predicate.lux
@@ -0,0 +1,57 @@
+(.module:
+  [lux #*
+   ["." function]]
+  [//
+   [monoid (#+ Monoid)]
+   [functor (#+ Contravariant)]])
+
+(type: #export (Predicate a)
+  (-> a Bit))
+
+(template [<identity-name> <identity-value> <composition-name> <composition>]
+  [(def: #export <identity-name>
+     (All [a] (Predicate a))
+     (function.constant <identity-value>))
+
+   (def: #export (<composition-name> left right)
+     (All [a] (-> (Predicate a) (Predicate a) (Predicate a)))
+     (function (_ value)
+       (<composition> (left value)
+                      (right value))))]
+
+  [none #0 union        or]
+  [all  #1 intersection and]
+  )
+
+(template [<name> <identity> <composition>]
+  [(structure: #export <name>
+     (All [a] (Monoid (Predicate a)))
+     
+     (def: identity <identity>)
+     (def: compose <composition>))]
+
+  [Union@Monoid        none union]
+  [Intersection@Monoid all intersection]
+  )
+
+(def: #export (complement predicate)
+  (All [a] (-> (Predicate a) (Predicate a)))
+  (|>> predicate not))
+
+(def: #export (difference sub base)
+  (All [a] (-> (Predicate a) (Predicate a) (Predicate a)))
+  (function (_ value)
+    (and (base value)
+         (not (sub value)))))
+
+(def: #export (rec predicate)
+  (All [a]
+    (-> (-> (Predicate a) (Predicate a))
+        (Predicate a)))
+  (|>> (predicate (rec predicate))))
+
+(structure: #export _
+  (Contravariant Predicate)
+  
+  (def: (map-1 f fb)
+    (|>> f fb)))
diff --git a/stdlib/source/lux/cli.lux b/stdlib/source/lux/cli.lux
index 34f4fa31c..2ee55a9b5 100644
--- a/stdlib/source/lux/cli.lux
+++ b/stdlib/source/lux/cli.lux
@@ -1,19 +1,20 @@
 (.module:
   [lux #*
+   [abstract
+    [monad (#+ do)]]
    [control
-    monad
     ["p" parser (#+ Parser)]
     [concurrency
      ["." process]]]
    [data
     [collection
-     ["." list ("#;." monoid monad)]]
-    ["." text ("#;." equivalence)
+     ["." list ("#@." monoid monad)]]
+    ["." text ("#@." equivalence)
      format]
     ["." error (#+ Error)]]
    [macro (#+ with-gensyms)
     ["." code]
-    ["s" syntax (#+ syntax: Syntax)]]
+    ["s" syntax (#+ Syntax syntax:)]]
    [tool
     [compiler
      ["." host]]]
@@ -63,7 +64,7 @@
   (function (_ inputs)
     (do error.monad
       [[remaining raw] (any inputs)]
-      (if (text;= reference raw)
+      (if (text@= reference raw)
         (wrap [remaining []])
         (error.fail (format "Missing token: '" reference "'"))))))
 
@@ -131,7 +132,7 @@
                   (wrap [])))
 
               (program: [name]
-                (io (log! (text;compose "Hello, " name))))
+                (io (log! (text@compose "Hello, " name))))
 
               (program: [{config config^}]
                 (do io.monad
@@ -153,9 +154,9 @@
                           (case ((: (~! (..CLI (io.IO .Any)))
                                     ((~! do) (~! p.monad)
                                      [(~+ (|> args
-                                              (list;map (function (_ [binding parser])
+                                              (list@map (function (_ [binding parser])
                                                           (list binding parser)))
-                                              list;join))
+                                              list@join))
                                       (~ g!_) ..end]
                                      ((~' wrap) ((~! do) (~! io.monad)
                                                  [(~ g!output) (~ body)
diff --git a/stdlib/source/lux/control/algebra.lux b/stdlib/source/lux/control/algebra.lux
deleted file mode 100644
index 2813ed0e7..000000000
--- a/stdlib/source/lux/control/algebra.lux
+++ /dev/null
@@ -1,17 +0,0 @@
-(.module:
-  [lux #*
-   [control
-    functor]])
-
-## Types
-(type: #export (Algebra f a)
-  (-> (f a) a))
-
-(type: #export (CoAlgebra f a)
-  (-> a (f a)))
-
-(type: #export (RAlgebra f a)
-  (-> (f (& (Fix f) a)) a))
-
-(type: #export (RCoAlgebra f a)
-  (-> a (f (| (Fix f) a))))
diff --git a/stdlib/source/lux/control/apply.lux b/stdlib/source/lux/control/apply.lux
deleted file mode 100644
index 5eb42b63d..000000000
--- a/stdlib/source/lux/control/apply.lux
+++ /dev/null
@@ -1,36 +0,0 @@
-(.module:
-  lux
-  [//
-   ["." functor (#+ Functor)]
-   [monad (#+ Monad)]])
-
-(signature: #export (Apply f)
-  {#.doc "Applicative functors."}
-  (: (Functor f)
-     &functor)
-  (: (All [a b]
-       (-> (f (-> a b)) (f a) (f b)))
-     apply))
-
-(structure: #export (compose f-monad f-apply g-apply)
-  {#.doc "Applicative functor composition."}
-  (All [F G]
-    (-> (Monad F) (Apply F) (Apply G)
-        ## TODO: Replace (All [a] (F (G a))) with (functor.Then F G)
-        (Apply (All [a] (F (G a))))))
-  
-  (def: &functor (functor.compose (get@ #&functor f-apply) (get@ #&functor g-apply)))
-  
-  (def: (apply fgf fgx)
-    ## TODO: Switch from this version to the one below (in comments) ASAP.
-    (let [fgf' (:: f-apply apply
-                   (:: f-monad wrap (:: g-apply apply))
-                   fgf)]
-      (:: f-apply apply fgf' fgx))
-    ## (let [applyF (:: f-apply apply)
-    ##       applyG (:: g-apply apply)]
-    ##   ($_ applyF
-    ##       (:: f-monad wrap applyG)
-    ##       fgf
-    ##       fgx))
-    ))
diff --git a/stdlib/source/lux/control/codec.lux b/stdlib/source/lux/control/codec.lux
deleted file mode 100644
index b51f76d97..000000000
--- a/stdlib/source/lux/control/codec.lux
+++ /dev/null
@@ -1,29 +0,0 @@
-(.module:
-  [lux #*
-   [control
-    monad]
-   [data
-    ["." error (#+ Error)]]])
-
-## [Signatures]
-(signature: #export (Codec m a)
-  {#.doc "A way to move back-and-forth between a type and an alternative representation for it."}
-  (: (-> a m)
-     encode)
-  (: (-> m (Error a))
-     decode))
-
-## [Values]
-(structure: #export (compose cb-codec ba-codec)
-  {#.doc "Codec composition."}
-  (All [a b c]
-    (-> (Codec c b) (Codec b a)
-        (Codec c a)))
-  (def: encode
-    (|>> (:: ba-codec encode)
-         (:: cb-codec encode)))
-
-  (def: (decode cy)
-    (do error.monad
-      [by (:: cb-codec decode cy)]
-      (:: ba-codec decode by))))
diff --git a/stdlib/source/lux/control/comonad.lux b/stdlib/source/lux/control/comonad.lux
deleted file mode 100644
index 1d6ac49e5..000000000
--- a/stdlib/source/lux/control/comonad.lux
+++ /dev/null
@@ -1,62 +0,0 @@
-(.module:
-  [lux #*
-   [data
-    [collection
-     ["." list ("#;." fold)]]]]
-  [//
-   ["." functor (#+ Functor)]])
-
-(signature: #export (CoMonad w)
-  {#.doc (doc "CoMonads are the opposite/complement to monads."
-              "CoMonadic structures are often infinite in size and built upon lazily-evaluated functions.")}
-  (: (Functor w)
-     &functor)
-  (: (All [a]
-       (-> (w a) a))
-     unwrap)
-  (: (All [a]
-       (-> (w a) (w (w a))))
-     split))
-
-(type: #export (CoFree F a)
-  {#.doc "The CoFree CoMonad."}
-  [a (F (CoFree F a))])
-
-(def: _cursor Cursor ["" 0 0])
-
-(macro: #export (be tokens state)
-  {#.doc (doc "A co-monadic parallel to the 'do' macro."
-              (let [square (function (_ n) (i/* n n))]
-                (be comonad
-                  [inputs (iterate inc +2)]
-                  (square (head inputs)))))}
-  (case tokens
-    (#.Cons comonad (#.Cons [_ (#.Tuple bindings)] (#.Cons body #.Nil)))
-    (if (|> bindings list.size (n/% 2) (n/= 0))
-      (let [g!_ (: Code [_cursor (#.Identifier ["" " _ "])])
-            g!map (: Code [_cursor (#.Identifier ["" " map "])])
-            g!split (: Code [_cursor (#.Identifier ["" " split "])])
-            body' (list;fold (: (-> [Code Code] Code Code)
-                                (function (_ binding body')
-                                  (let [[var value] binding]
-                                    (case var
-                                      [_ (#.Tag ["" "let"])]
-                                      (` (let (~ value) (~ body')))
-
-                                      _
-                                      (` (|> (~ value) (~ g!split) ((~ g!map) (function ((~ g!_) (~ var)) (~ body')))))
-                                      ))))
-                             body
-                             (list.reverse (list.as-pairs bindings)))]
-        (#.Right [state (#.Cons (` ({(~' @)
-                                     ({{#&functor {#functor.map (~ g!map)}
-                                        #unwrap (~' unwrap)
-                                        #split (~ g!split)}
-                                       (~ body')}
-                                      (~' @))}
-                                    (~ comonad)))
-                                #.Nil)]))
-      (#.Left "'be' bindings must have an even number of parts."))
-
-    _
-    (#.Left "Wrong syntax for 'be'")))
diff --git a/stdlib/source/lux/control/concatenative.lux b/stdlib/source/lux/control/concatenative.lux
index 2ec99fe8f..9a20132fd 100644
--- a/stdlib/source/lux/control/concatenative.lux
+++ b/stdlib/source/lux/control/concatenative.lux
@@ -4,8 +4,7 @@
            i/+ i/- i/* i// i/% i/= i/< i/<= i/> i/>=
            r/+ r/- r/* r// r/% r/= r/< r/<= r/> r/>=
            f/+ f/- f/* f// f/% f/= f/< f/<= f/> f/>=)
-   [control
-    ["p" parser ("#;." monad)]
+   [abstract
     ["." monad]]
    [data
     ["." text
@@ -19,7 +18,9 @@
     [syntax
      ["cs" common
       ["csr" reader]
-      ["csw" writer]]]]])
+      ["csw" writer]]]]]
+  [//
+   ["p" parser ("#;." monad)]])
 
 ## [Syntax]
 (type: Alias [Text Code])
diff --git a/stdlib/source/lux/control/concurrency/actor.lux b/stdlib/source/lux/control/concurrency/actor.lux
index 133144a83..3384b7b66 100644
--- a/stdlib/source/lux/control/concurrency/actor.lux
+++ b/stdlib/source/lux/control/concurrency/actor.lux
@@ -1,7 +1,9 @@
 (.module: {#.doc "The actor model of concurrency."}
   [lux #*
    ["." function]
-   [control monad
+   [abstract
+    monad]
+   [control
     ["p" parser]
     ["ex" exception (#+ exception:)]]
    ["." io (#+ IO io) ("#;." monad)]
diff --git a/stdlib/source/lux/control/concurrency/atom.lux b/stdlib/source/lux/control/concurrency/atom.lux
index a8fd975b2..6b88a0a4a 100644
--- a/stdlib/source/lux/control/concurrency/atom.lux
+++ b/stdlib/source/lux/control/concurrency/atom.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monad (#+ do)]]
    ["." function]
    ["." io (#- run)]
diff --git a/stdlib/source/lux/control/concurrency/frp.lux b/stdlib/source/lux/control/concurrency/frp.lux
index 907ffa97d..74212594f 100644
--- a/stdlib/source/lux/control/concurrency/frp.lux
+++ b/stdlib/source/lux/control/concurrency/frp.lux
@@ -1,12 +1,13 @@
 (.module:
   [lux #*
    ["." io (#+ IO io)]
-   [control
+   [abstract
     [predicate (#+ Predicate)]
     [equivalence (#+ Equivalence)]
     [functor (#+ Functor)]
     [apply (#+ Apply)]
-    ["." monad (#+ Monad do)]
+    ["." monad (#+ Monad do)]]
+   [control
     ["ex" exception (#+ exception:)]]
    [data
     ["." maybe ("#@." functor)]
diff --git a/stdlib/source/lux/control/concurrency/process.lux b/stdlib/source/lux/control/concurrency/process.lux
index 018659ba1..96963a7f2 100644
--- a/stdlib/source/lux/control/concurrency/process.lux
+++ b/stdlib/source/lux/control/concurrency/process.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    ["." monad (#+ do)]]
    [control
-    ["." monad (#+ do)]
     ["ex" exception (#+ exception:)]]
    [data
     [collection
diff --git a/stdlib/source/lux/control/concurrency/promise.lux b/stdlib/source/lux/control/concurrency/promise.lux
index fa8acc6d9..63f506c37 100644
--- a/stdlib/source/lux/control/concurrency/promise.lux
+++ b/stdlib/source/lux/control/concurrency/promise.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux (#- and or)
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     ["." monad (#+ Monad do)]]
diff --git a/stdlib/source/lux/control/concurrency/semaphore.lux b/stdlib/source/lux/control/concurrency/semaphore.lux
index 2bc5be651..1159e41e6 100644
--- a/stdlib/source/lux/control/concurrency/semaphore.lux
+++ b/stdlib/source/lux/control/concurrency/semaphore.lux
@@ -1,6 +1,7 @@
 (.module:
   [lux #*
-   [control [monad (#+ do)]]
+   [abstract
+    [monad (#+ do)]]
    ["." io (#+ IO)]
    [type
     abstract
diff --git a/stdlib/source/lux/control/concurrency/stm.lux b/stdlib/source/lux/control/concurrency/stm.lux
index 1bc69f5e2..fce9cbd82 100644
--- a/stdlib/source/lux/control/concurrency/stm.lux
+++ b/stdlib/source/lux/control/concurrency/stm.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     ["." monad (#+ do Monad)]]
diff --git a/stdlib/source/lux/control/continuation.lux b/stdlib/source/lux/control/continuation.lux
index 7a1fd7be8..e960e1fd3 100644
--- a/stdlib/source/lux/control/continuation.lux
+++ b/stdlib/source/lux/control/continuation.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     [monad (#+ Monad do)]]
diff --git a/stdlib/source/lux/control/contract.lux b/stdlib/source/lux/control/contract.lux
index 065829f44..1add3be8f 100644
--- a/stdlib/source/lux/control/contract.lux
+++ b/stdlib/source/lux/control/contract.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     monad]
    [data
     [text
diff --git a/stdlib/source/lux/control/enum.lux b/stdlib/source/lux/control/enum.lux
deleted file mode 100644
index 9f2845b01..000000000
--- a/stdlib/source/lux/control/enum.lux
+++ /dev/null
@@ -1,21 +0,0 @@
-(.module:
-  [lux #*
-   [control
-    ["." order]]])
-
-(signature: #export (Enum e)
-  {#.doc "Enumerable types, with a notion of moving forward and backwards through a type's instances."}
-  (: (order.Order e) &order)
-  (: (-> e e) succ)
-  (: (-> e e) pred))
-
-(def: (range' <= succ from to)
-  (All [a] (-> (-> a a Bit) (-> a a) a a (List a)))
-  (if (<= to from)
-    (#.Cons from (range' <= succ (succ from) to))
-    #.Nil))
-
-(def: #export (range (^open ".") from to)
-  {#.doc "An inclusive [from, to] range of values."}
-  (All [a] (-> (Enum a) a a (List a)))
-  (range' <= succ from to))
diff --git a/stdlib/source/lux/control/equivalence.lux b/stdlib/source/lux/control/equivalence.lux
deleted file mode 100644
index 57db7a925..000000000
--- a/stdlib/source/lux/control/equivalence.lux
+++ /dev/null
@@ -1,42 +0,0 @@
-(.module:
-  [lux #*
-   [control
-    [functor (#+ Contravariant)]]])
-
-(signature: #export (Equivalence a)
-  {#.doc "Equivalence for a type's instances."}
-  (: (-> a a Bit)
-     =))
-
-(def: #export (product left right)
-  (All [l r] (-> (Equivalence l) (Equivalence r) (Equivalence [l r])))
-  (structure
-   (def: (= [a b] [x y])
-     (and (:: left = a x)
-          (:: right = b y)))))
-
-(def: #export (sum left right)
-  (All [l r] (-> (Equivalence l) (Equivalence r) (Equivalence (| l r))))
-  (structure
-   (def: (= a|b x|y)
-     (case [a|b x|y]
-       [(0 a) (0 x)]
-       (:: left = a x)
-
-       [(1 b) (1 y)]
-       (:: right = b y)
-
-       _
-       #0))))
-
-(def: #export (rec sub)
-  (All [a] (-> (-> (Equivalence a) (Equivalence a)) (Equivalence a)))
-  (structure
-   (def: (= left right)
-     (sub (rec sub) left right))))
-
-(structure: #export contravariant (Contravariant Equivalence)
-  (def: (map-1 f equivalence)
-    (structure
-     (def: (= reference sample)
-       (:: equivalence = (f reference) (f sample))))))
diff --git a/stdlib/source/lux/control/exception.lux b/stdlib/source/lux/control/exception.lux
index 71cfa3414..4472b047c 100644
--- a/stdlib/source/lux/control/exception.lux
+++ b/stdlib/source/lux/control/exception.lux
@@ -1,7 +1,8 @@
 (.module: {#.doc "Exception-handling functionality built on top of the Error type."}
   [lux #*
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["p" parser]]
    [data
     ["//" error (#+ Error)]
diff --git a/stdlib/source/lux/control/fold.lux b/stdlib/source/lux/control/fold.lux
deleted file mode 100644
index 504f41f58..000000000
--- a/stdlib/source/lux/control/fold.lux
+++ /dev/null
@@ -1,18 +0,0 @@
-(.module:
-  [lux #*]
-  [//
-   [monoid (#+ Monoid)]])
-
-(signature: #export (Fold F)
-  {#.doc "Iterate over a structure's values to build a summary value."}
-  (: (All [a b]
-       (-> (-> b a a) a (F b) a))
-     fold))
-
-(def: #export (with-monoid monoid fold value)
-  (All [F a]
-    (-> (Monoid a) (Fold F) (F a) a))
-  (let [(^open "monoid;.") monoid]
-    (fold monoid;compose
-          monoid;identity
-          value)))
diff --git a/stdlib/source/lux/control/functor.lux b/stdlib/source/lux/control/functor.lux
deleted file mode 100644
index 1ade0a45b..000000000
--- a/stdlib/source/lux/control/functor.lux
+++ /dev/null
@@ -1,32 +0,0 @@
-(.module: lux)
-
-(signature: #export (Functor f)
-  (: (All [a b]
-       (-> (-> a b)
-           (-> (f a) (f b))))
-     map))
-
-(type: #export (Fix f)
-  (f (Fix f)))
-
-(type: #export (And f g)
-  (All [a] (& (f a) (g a))))
-
-(type: #export (Or f g)
-  (All [a] (| (f a) (g a))))
-
-(type: #export (Then f g)
-  (All [a] (f (g a))))
-
-(def: #export (compose f-functor g-functor)
-  {#.doc "Functor composition."}
-  (All [F G] (-> (Functor F) (Functor G) (Functor (..Then F G))))
-  (structure
-   (def: (map f fga)
-     (:: f-functor map (:: g-functor map f) fga))))
-
-(signature: #export (Contravariant f)
-  (: (All [a b]
-       (-> (-> b a)
-           (-> (f a) (f b))))
-     map-1))
diff --git a/stdlib/source/lux/control/hash.lux b/stdlib/source/lux/control/hash.lux
deleted file mode 100644
index d2dee3bcb..000000000
--- a/stdlib/source/lux/control/hash.lux
+++ /dev/null
@@ -1,13 +0,0 @@
-(.module:
-  lux
-  [//
-   [equivalence (#+ Equivalence)]])
-
-## [Signatures]
-(signature: #export (Hash a)
-  {#.doc (doc "A way to produce hash-codes for a type's instances."
-              "A necessity when working with some data-structures, such as dictionaries or sets.")}
-  (: (Equivalence a)
-     &equivalence)
-  (: (-> a Nat)
-     hash))
diff --git a/stdlib/source/lux/control/interval.lux b/stdlib/source/lux/control/interval.lux
deleted file mode 100644
index 046f5b77d..000000000
--- a/stdlib/source/lux/control/interval.lux
+++ /dev/null
@@ -1,184 +0,0 @@
-(.module:
-  [lux #*
-   [control
-    [equivalence (#+ Equivalence)]
-    ["." order]
-    [enum (#+ Enum)]]])
-
-(signature: #export (Interval a)
-  {#.doc "A representation of top and bottom boundaries for an ordered type."}
-  (: (Enum a)
-     &enum)
-
-  (: a
-     bottom)
-
-  (: a
-     top))
-
-(def: #export (between enum bottom top)
-  (All [a] (-> (Enum a) a a (Interval a)))
-  (structure (def: &enum enum)
-             (def: bottom bottom)
-             (def: top top)))
-
-(def: #export (singleton enum elem)
-  (All [a] (-> (Enum a) a (Interval a)))
-  (structure (def: &enum enum)
-             (def: bottom elem)
-             (def: top elem)))
-
-(template [<name> <comp>]
-  [(def: #export (<name> interval)
-     (All [a] (-> (Interval a) Bit))
-     (let [(^open ".") interval]
-       (<comp> bottom top)))]
-
-  [inner?     >]
-  [outer?     <]
-  [singleton? =]
-  )
-
-(def: #export (within? interval elem)
-  (All [a] (-> (Interval a) a Bit))
-  (let [(^open ".") interval]
-    (cond (inner? interval)
-          (and (>= bottom elem)
-               (<= top elem))
-          
-          (outer? interval)
-          (or (>= bottom elem)
-              (<= top elem))
-          
-          ## singleton
-          (and (= bottom elem)
-               (= top elem)))))
-
-(template [<name> <limit>]
-  [(def: #export (<name> elem interval)
-     (All [a] (-> a (Interval a) Bit))
-     (let [(^open ".") interval]
-       (= <limit> elem)))]
-
-  [starts-with? bottom]
-  [ends-with?   top]
-  )
-
-(def: #export (borders? interval elem)
-  (All [a] (-> (Interval a) a Bit))
-  (or (starts-with? elem interval)
-      (ends-with? elem interval)))
-
-(def: #export (union left right)
-  (All [a] (-> (Interval a) (Interval a) (Interval a)))
-  (structure (def: &enum (get@ #&enum right))
-             (def: bottom (order.min (:: right &order) (:: left bottom) (:: right bottom)))
-             (def: top (order.max (:: right &order) (:: left top) (:: right top)))))
-
-(def: #export (intersection left right)
-  (All [a] (-> (Interval a) (Interval a) (Interval a)))
-  (structure (def: &enum (get@ #&enum right))
-             (def: bottom (order.max (:: right &order) (:: left bottom) (:: right bottom)))
-             (def: top (order.min (:: right &order) (:: left top) (:: right top)))))
-
-(def: #export (complement interval)
-  (All [a] (-> (Interval a) (Interval a)))
-  (let [(^open ".") interval]
-    (structure (def: &enum (get@ #&enum interval))
-               (def: bottom (succ top))
-               (def: top (pred bottom)))))
-
-(def: #export (precedes? reference sample)
-  (All [a] (-> (Interval a) (Interval a) Bit))
-  (let [(^open ".") reference
-        limit (:: reference bottom)]
-    (and (< limit (:: sample bottom))
-         (< limit (:: sample top)))))
-
-(def: #export (succeeds? reference sample)
-  (All [a] (-> (Interval a) (Interval a) Bit))
-  (precedes? sample reference))
-
-(def: #export (meets? reference sample)
-  (All [a] (-> (Interval a) (Interval a) Bit))
-  (let [(^open ".") reference
-        limit (:: reference bottom)]
-    (and (<= limit (:: sample bottom))
-         (= limit (:: sample top)))))
-
-(def: #export (touches? reference sample)
-  (All [a] (-> (Interval a) (Interval a) Bit))
-  (or (meets? reference sample)
-      (meets? sample reference)))
-
-(template [<name> <eq-side> <ineq> <ineq-side>]
-  [(def: #export (<name> reference sample)
-     (All [a] (-> (Interval a) (Interval a) Bit))
-     (let [(^open ".") reference]
-       (and (=      (:: reference <eq-side>)   (:: sample <eq-side>))
-            (<ineq> (:: reference <ineq-side>) (:: sample <ineq-side>)))))]
-
-  [starts?   bottom <= top]
-  [finishes? top    >= bottom]
-  )
-
-(template [<name> <comp>]
-  [(def: #export (<name> reference sample)
-     (All [a] (-> a (Interval a) Bit))
-     (let [(^open ".") sample]
-       (and (<comp> reference bottom)
-            (<comp> reference top))))]
-
-  [before? <]
-  [after?  >]
-  )
-
-(structure: #export equivalence (All [a] (Equivalence (Interval a)))
-  (def: (= reference sample)
-    (let [(^open "_;.") reference]
-      (and (_;= _;bottom (:: sample bottom))
-           (_;= _;top (:: sample top))))))
-
-(def: #export (nested? reference sample)
-  (All [a] (-> (Interval a) (Interval a) Bit))
-  (cond (or (singleton? sample)
-            (and (inner? reference) (inner? sample))
-            (and (outer? reference) (outer? sample)))
-        (let [(^open ".") reference]
-          (and (>= (:: reference bottom) (:: sample bottom))
-               (<= (:: reference top) (:: sample top))))
-
-        (or (singleton? reference)
-            (and (inner? reference) (outer? sample)))
-        #0
-
-        ## (and (outer? reference) (inner? sample))
-        (let [(^open ".") reference]
-          (or (and (>= (:: reference bottom) (:: sample bottom))
-                   (> (:: reference bottom) (:: sample top)))
-              (and (< (:: reference top) (:: sample bottom))
-                   (<= (:: reference top) (:: sample top)))))
-        ))
-
-(def: #export (overlaps? reference sample)
-  (All [a] (-> (Interval a) (Interval a) Bit))
-  (let [(^open ".") reference]
-    (and (not (:: ..equivalence = reference sample))
-         (cond (singleton? sample)
-               #0
-
-               (singleton? reference)
-               (nested? sample reference)
-
-               (or (and (inner? sample) (outer? reference))
-                   (and (outer? sample) (inner? reference)))
-               (or (>= (:: reference bottom) (:: sample top))
-                   (<= (:: reference top) (:: sample bottom)))
-
-               ## both inner
-               (inner? sample)
-               (inner? (intersection reference sample))
-
-               ## both outer
-               (not (nested? reference sample))
-               ))))
diff --git a/stdlib/source/lux/control/monad.lux b/stdlib/source/lux/control/monad.lux
deleted file mode 100644
index 513f55b1e..000000000
--- a/stdlib/source/lux/control/monad.lux
+++ /dev/null
@@ -1,168 +0,0 @@
-(.module:
-  lux
-  [//
-   ["." functor (#+ Functor)]])
-
-(def: (list;fold f init xs)
-  (All [a b]
-    (-> (-> b a a) a (List b) a)) 
-  (case xs
-    #.Nil
-    init
-
-    (#.Cons x xs')
-    (list;fold f (f x init) xs')))
-
-(def: (list;size xs)
-  (All [a] (-> (List a) Nat))
-  (loop [counter 0
-         xs xs]
-    (case xs
-      #.Nil
-      counter
-
-      (#.Cons _ xs')
-      (recur (inc counter) xs'))))
-
-(def: (reverse xs)
-  (All [a]
-    (-> (List a) (List a)))
-  (list;fold (function (_ head tail) (#.Cons head tail))
-             #.Nil
-             xs))
-
-(def: (as-pairs xs)
-  (All [a] (-> (List a) (List [a a])))
-  (case xs
-    (#.Cons x1 (#.Cons x2 xs'))
-    (#.Cons [x1 x2] (as-pairs xs'))
-
-    _
-    #.Nil))
-
-(signature: #export (Monad m)
-  (: (Functor m)
-     &functor)
-  (: (All [a]
-       (-> a (m a)))
-     wrap)
-  (: (All [a]
-       (-> (m (m a)) (m a)))
-     join))
-
-(def: _cursor Cursor ["" 0 0])
-
-(macro: #export (do tokens state)
-  {#.doc (doc "Macro for easy concatenation of monadic operations."
-              (do monad
-                [y (f1 x)
-                 z (f2 z)]
-                (wrap (f3 z))))}
-  (case tokens
-    (#.Cons monad (#.Cons [_ (#.Tuple bindings)] (#.Cons body #.Nil)))
-    (if (|> bindings list;size (n/% 2) (n/= 0))
-      (let [g!_ (: Code [_cursor (#.Identifier ["" " _ "])])
-            g!map (: Code [_cursor (#.Identifier ["" " map "])])
-            g!join (: Code [_cursor (#.Identifier ["" " join "])])
-            body' (list;fold (: (-> [Code Code] Code Code)
-                                (function (_ binding body')
-                                  (let [[var value] binding]
-                                    (case var
-                                      [_ (#.Tag ["" "let"])]
-                                      (` (let (~ value) (~ body')))
-
-                                      _
-                                      (` (|> (~ value) ((~ g!map) (function ((~ g!_) (~ var)) (~ body'))) (~ g!join)))
-                                      ))))
-                             body
-                             (reverse (as-pairs bindings)))]
-        (#.Right [state (#.Cons (` ({(~' @)
-                                     ({{#..&functor {#functor.map (~ g!map)}
-                                        #..wrap (~' wrap)
-                                        #..join (~ g!join)}
-                                       (~ body')}
-                                      (~' @))}
-                                    (~ monad)))
-                                #.Nil)]))
-      (#.Left "'do' bindings must have an even number of parts."))
-
-    _
-    (#.Left "Wrong syntax for 'do'")))
-
-(def: #export (seq monad)
-  {#.doc "Run all the monadic values in the list and produce a list of the base values."}
-  (All [M a]
-    (-> (Monad M) (List (M a))
-        (M (List a))))
-  (let [(^open "!;.") monad]
-    (function (recur xs)
-      (case xs
-        #.Nil
-        (!;wrap #.Nil)
-        
-        (#.Cons x xs')
-        (|> x
-            (!;map (function (_ _x)
-                     (!;map (|>> (#.Cons _x)) (recur xs'))))
-            !;join)))))
-
-(def: #export (map monad f)
-  {#.doc "Apply a monadic function to all values in a list."}
-  (All [M a b]
-    (-> (Monad M) (-> a (M b)) (List a)
-        (M (List b))))
-  (let [(^open "!;.") monad]
-    (function (recur xs)
-      (case xs
-        #.Nil
-        (!;wrap #.Nil)
-        
-        (#.Cons x xs')
-        (|> (f x)
-            (!;map (function (_ _x)
-                     (!;map (|>> (#.Cons _x)) (recur xs'))))
-            !;join)))))
-
-(def: #export (filter Monad<!> f)
-  {#.doc "Filter the values in a list with a monadic function."}
-  (All [! a b]
-    (-> (Monad !) (-> a (! Bit)) (List a)
-        (! (List a))))
-  (let [(^open "!;.") Monad<!>]
-    (function (recur xs)
-      (case xs
-        #.Nil
-        (!;wrap #.Nil)
-        
-        (#.Cons head xs')
-        (|> (f head)
-            (!;map (function (_ verdict)
-                     (!;map (function (_ tail)
-                              (if verdict
-                                (#.Cons head tail)
-                                tail))
-                            (recur xs'))))
-            !;join)))))
-
-(def: #export (fold monad f init xs)
-  {#.doc "Fold a list with a monadic function."}
-  (All [M a b]
-    (-> (Monad M) (-> b a (M a)) a (List b)
-        (M a)))
-  (case xs
-    #.Nil
-    (:: monad wrap init)
-
-    (#.Cons x xs')
-    (do monad
-      [init' (f x init)]
-      (fold monad f init' xs'))))
-
-(def: #export (lift monad f)
-  {#.doc "Lift a normal function into the space of monads."}
-  (All [M a b]
-    (-> (Monad M) (-> a b) (-> (M a) (M b))))
-  (function (_ ma)
-    (do monad
-      [a ma]
-      (wrap (f a)))))
diff --git a/stdlib/source/lux/control/monad/free.lux b/stdlib/source/lux/control/monad/free.lux
deleted file mode 100644
index 214261450..000000000
--- a/stdlib/source/lux/control/monad/free.lux
+++ /dev/null
@@ -1,67 +0,0 @@
-(.module:
-  lux
-  [///
-   [functor (#+ Functor)]
-   [apply (#+ Apply)]
-   [monad (#+ Monad)]])
-
-(type: #export (Free F a)
-  {#.doc "The Free Monad."}
-  (#Pure a)
-  (#Effect (F (Free F a))))
-
-(structure: #export (functor dsl)
-  (All [F] (-> (Functor F) (Functor (Free F))))
-  
-  (def: (map f ea)
-    (case ea
-      (#Pure a)
-      (#Pure (f a))
-      
-      (#Effect value)
-      (#Effect (:: dsl map (map f) value)))))
-
-(structure: #export (apply dsl)
-  (All [F] (-> (Functor F) (Apply (Free F))))
-  
-  (def: &functor (..functor dsl))
-
-  (def: (apply ef ea)
-    (case [ef ea]
-      [(#Pure f) (#Pure a)]
-      (#Pure (f a))
-
-      [(#Pure f) (#Effect fa)]
-      (#Effect (:: dsl map
-                   (:: (..functor dsl) map f)
-                   fa))
-
-      [(#Effect ff) _]
-      (#Effect (:: dsl map
-                   (function (_ f) (apply f ea))
-                   ff))
-      )))
-
-(structure: #export (monad dsl)
-  (All [F] (-> (Functor F) (Monad (Free F))))
-
-  (def: &functor (..functor dsl))
-
-  (def: (wrap a)
-    (#Pure a))
-
-  (def: (join efefa)
-    (case efefa
-      (#Pure efa)
-      (case efa
-        (#Pure a)
-        (#Pure a)
-
-        (#Effect fa)
-        (#Effect fa))
-      
-      (#Effect fefa)
-      (#Effect (:: dsl map
-                   (:: (monad dsl) join)
-                   fefa))
-      )))
diff --git a/stdlib/source/lux/control/monad/indexed.lux b/stdlib/source/lux/control/monad/indexed.lux
deleted file mode 100644
index 57a18c109..000000000
--- a/stdlib/source/lux/control/monad/indexed.lux
+++ /dev/null
@@ -1,64 +0,0 @@
-(.module:
-  [lux #*
-   [control
-    [monad]
-    ["p" parser]]
-   [data
-    [collection
-     ["." list ("#;." functor fold)]]]
-   ["." macro
-    ["s" syntax (#+ Syntax syntax:)]]])
-
-(signature: #export (IxMonad m)
-  (: (All [p a]
-       (-> a (m p p a)))
-     wrap)
-
-  (: (All [ii it io vi vo]
-       (-> (-> vi (m it io vo))
-           (m ii it vi)
-           (m ii io vo)))
-     bind))
-
-(type: Binding [Code Code])
-
-(def: binding
-  (Syntax Binding)
-  (p.and s.any s.any))
-
-(type: Context
-  (#Let (List Binding))
-  (#Bind Binding))
-
-(def: context
-  (Syntax Context)
-  (p.or (p.after (s.this (' #let))
-                 (s.tuple (p.some binding)))
-        binding))
-
-(def: (pair-list [binding value])
-  (All [a] (-> [a a] (List a)))
-  (list binding value))
-
-(syntax: #export (do monad
-                   {context (s.tuple (p.some context))}
-                   expression)
-  (macro.with-gensyms [g!_ g!bind]
-    (wrap (list (` (let [(~' @) (~ monad)
-                         {#..wrap (~' wrap)
-                          #..bind (~ g!bind)} (~' @)]
-                     (~ (list;fold (function (_ context next)
-                                     (case context
-                                       (#Let bindings)
-                                       (` (let [(~+ (|> bindings
-                                                        (list;map pair-list)
-                                                        list.concat))]
-                                            (~ next)))
-                                       
-                                       (#Bind [binding value])
-                                       (` ((~ g!bind)
-                                           (.function ((~ g!_) (~ binding))
-                                             (~ next))
-                                           (~ value)))))
-                                   expression
-                                   (list.reverse context)))))))))
diff --git a/stdlib/source/lux/control/monoid.lux b/stdlib/source/lux/control/monoid.lux
deleted file mode 100644
index 33d082020..000000000
--- a/stdlib/source/lux/control/monoid.lux
+++ /dev/null
@@ -1,19 +0,0 @@
-(.module:
-  [lux #*])
-
-(signature: #export (Monoid a)
-  {#.doc (doc "A way to compose values."
-              "Includes an identity value which does not alter any other value when combined with.")}
-  (: a
-     identity)
-  (: (-> a a a)
-     compose))
-
-(def: #export (compose Monoid<l> Monoid<r>)
-  (All [l r] (-> (Monoid l) (Monoid r) (Monoid [l r])))
-  (structure (def: identity
-               [(:: Monoid<l> identity) (:: Monoid<r> identity)])
-             
-             (def: (compose [lL rL] [lR rR])
-               [(:: Monoid<l> compose lL lR)
-                (:: Monoid<r> compose rL rR)])))
diff --git a/stdlib/source/lux/control/number.lux b/stdlib/source/lux/control/number.lux
deleted file mode 100644
index b3a314ba5..000000000
--- a/stdlib/source/lux/control/number.lux
+++ /dev/null
@@ -1,14 +0,0 @@
-(.module:
-  lux)
-
-(`` (signature: #export (Number n)
-      {#.doc "Everything that should be expected of a number type."}
-
-      (~~ (template [<name>]
-            [(: (-> n n n) <name>)]
-            [+] [-] [*] [/] [%]))
-
-      (~~ (template [<name>]
-            [(: (-> n n) <name>)]
-            [negate] [signum] [abs]))
-      ))
diff --git a/stdlib/source/lux/control/order.lux b/stdlib/source/lux/control/order.lux
deleted file mode 100644
index 68573b326..000000000
--- a/stdlib/source/lux/control/order.lux
+++ /dev/null
@@ -1,60 +0,0 @@
-(.module:
-  [lux #*
-   [control
-    [functor (#+ Contravariant)]]
-   function]
-  [//
-   ["." equivalence (#+ Equivalence)]])
-
-(`` (signature: #export (Order a)
-      {#.doc "A signature for types that possess some sense of ordering among their elements."}
-      
-      (: (Equivalence a)
-         &equivalence)
-      
-      (~~ (template [<name>]
-            [(: (-> a a Bit) <name>)]
-
-            [<] [<=] [>] [>=]
-            ))
-      ))
-
-(def: #export (order equivalence <)
-  (All [a]
-    (-> (Equivalence a) (-> a a Bit) (Order a)))
-  (let [> (flip <)]
-    (structure (def: &equivalence equivalence)
-               
-               (def: < <)
-               
-               (def: (<= test subject)
-                 (or (< test subject)
-                     (:: equivalence = test subject)))
-               
-               (def: > >)
-               
-               (def: (>= test subject)
-                 (or (> test subject)
-                     (:: equivalence = test subject))))))
-
-(template [<name> <op>]
-  [(def: #export (<name> order x y)
-     (All [a]
-       (-> (Order a) a a a))
-     (if (:: order <op> y x) x y))]
-
-  [min <]
-  [max >]
-  )
-
-(`` (structure: #export contravariant (Contravariant Order)
-      (def: (map-1 f order)
-        (structure
-         (def: &equivalence (:: equivalence.contravariant map-1 f (:: order &equivalence)))
-         
-         (~~ (template [<name>]
-               [(def: (<name> reference sample)
-                  (:: order <name> (f reference) (f sample)))]
-
-               [<] [<=] [>] [>=]
-               ))))))
diff --git a/stdlib/source/lux/control/parser.lux b/stdlib/source/lux/control/parser.lux
index 035576cab..84f63c548 100644
--- a/stdlib/source/lux/control/parser.lux
+++ b/stdlib/source/lux/control/parser.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux (#- or and not)
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     [monad (#+ Monad do)]
@@ -15,7 +15,9 @@
   {#.doc "A generic parser."}
   (-> s (Error [s a])))
 
-(structure: #export functor (All [s] (Functor (Parser s)))
+(structure: #export functor
+  (All [s] (Functor (Parser s)))
+  
   (def: (map f ma)
     (function (_ input)
       (case (ma input)
@@ -25,7 +27,9 @@
         (#error.Success [input' a])
         (#error.Success [input' (f a)])))))
 
-(structure: #export apply (All [s] (Apply (Parser s)))
+(structure: #export apply
+  (All [s] (Apply (Parser s)))
+  
   (def: &functor ..functor)
 
   (def: (apply ff fa)
@@ -42,7 +46,9 @@
         (#error.Failure msg)
         (#error.Failure msg)))))
 
-(structure: #export monad (All [s] (Monad (Parser s)))
+(structure: #export monad
+  (All [s] (Monad (Parser s)))
+  
   (def: &functor ..functor)
 
   (def: (wrap x)
diff --git a/stdlib/source/lux/control/pipe.lux b/stdlib/source/lux/control/pipe.lux
index 8700217e2..b6381e7a6 100644
--- a/stdlib/source/lux/control/pipe.lux
+++ b/stdlib/source/lux/control/pipe.lux
@@ -1,7 +1,8 @@
 (.module: {#.doc "Composable extensions to the piping macros (|> and <|) that enhance them with various abilities."}
   [lux #*
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["p" parser]]
    [data
     ["e" error]
diff --git a/stdlib/source/lux/control/predicate.lux b/stdlib/source/lux/control/predicate.lux
deleted file mode 100644
index 7d6433f33..000000000
--- a/stdlib/source/lux/control/predicate.lux
+++ /dev/null
@@ -1,53 +0,0 @@
-(.module:
-  [lux #*
-   [control
-    [monoid (#+ Monoid)]
-    [functor (#+ Contravariant)]]
-   ["." function]])
-
-(type: #export (Predicate a)
-  (-> a Bit))
-
-(template [<identity-name> <identity-value> <composition-name> <composition>]
-  [(def: #export <identity-name>
-     (All [a] (Predicate a))
-     (function.constant <identity-value>))
-
-   (def: #export (<composition-name> left right)
-     (All [a] (-> (Predicate a) (Predicate a) (Predicate a)))
-     (function (_ value)
-       (<composition> (left value)
-                      (right value))))]
-
-  [none #0 union        or]
-  [all  #1 intersection and]
-  )
-
-(template [<name> <identity> <composition>]
-  [(structure: #export <name> (All [a] (Monoid (Predicate a)))
-     (def: identity <identity>)
-     (def: compose <composition>))]
-
-  [Union@Monoid        none union]
-  [Intersection@Monoid all intersection]
-  )
-
-(def: #export (complement predicate)
-  (All [a] (-> (Predicate a) (Predicate a)))
-  (|>> predicate not))
-
-(def: #export (difference sub base)
-  (All [a] (-> (Predicate a) (Predicate a) (Predicate a)))
-  (function (_ value)
-    (and (base value)
-         (not (sub value)))))
-
-(def: #export (rec predicate)
-  (All [a]
-    (-> (-> (Predicate a) (Predicate a))
-        (Predicate a)))
-  (|>> (predicate (rec predicate))))
-
-(structure: #export _ (Contravariant Predicate)
-  (def: (map-1 f fb)
-    (|>> f fb)))
diff --git a/stdlib/source/lux/control/reader.lux b/stdlib/source/lux/control/reader.lux
index 01b139b82..9236fb5a5 100644
--- a/stdlib/source/lux/control/reader.lux
+++ b/stdlib/source/lux/control/reader.lux
@@ -1,9 +1,9 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." functor (#+ Functor)]
     [apply (#+ Apply)]
-    ["." monad (#+ do Monad)]]])
+    ["." monad (#+ Monad do)]]])
 
 (type: #export (Reader r a)
   {#.doc "Computations that have access to some environmental value."}
diff --git a/stdlib/source/lux/control/region.lux b/stdlib/source/lux/control/region.lux
index 596b1a0d4..0671e1c08 100644
--- a/stdlib/source/lux/control/region.lux
+++ b/stdlib/source/lux/control/region.lux
@@ -1,16 +1,17 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
-    ["." monad (#+ Monad do)]
-    ["ex" exception (#+ Exception exception:)]]
+    ["." monad (#+ Monad do)]]
    [data
     ["." error (#+ Error)]
     ["." text
      format]
     [collection
-     ["." list ("#;." fold)]]]])
+     ["." list ("#;." fold)]]]]
+  [//
+   ["ex" exception (#+ Exception exception:)]])
 
 (type: (Cleaner r m)
   (-> r (m (Error Any))))
diff --git a/stdlib/source/lux/control/remember.lux b/stdlib/source/lux/control/remember.lux
index 34bb38001..6d21a1948 100644
--- a/stdlib/source/lux/control/remember.lux
+++ b/stdlib/source/lux/control/remember.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["p" parser ("#@." functor)]
     ["ex" exception (#+ exception:)]]
    [data
diff --git a/stdlib/source/lux/control/security/capability.lux b/stdlib/source/lux/control/security/capability.lux
index 595c573d5..4684c8bdf 100644
--- a/stdlib/source/lux/control/security/capability.lux
+++ b/stdlib/source/lux/control/security/capability.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux #*
    ["." io (#+ IO)]
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["p" parser]
     [concurrency
      ["." promise (#+ Promise)]]]
diff --git a/stdlib/source/lux/control/security/integrity.lux b/stdlib/source/lux/control/security/integrity.lux
index 81dee0c16..625f3c431 100644
--- a/stdlib/source/lux/control/security/integrity.lux
+++ b/stdlib/source/lux/control/security/integrity.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     [monad (#+ Monad)]]
diff --git a/stdlib/source/lux/control/security/privacy.lux b/stdlib/source/lux/control/security/privacy.lux
index fe6a70233..4a54947b1 100644
--- a/stdlib/source/lux/control/security/privacy.lux
+++ b/stdlib/source/lux/control/security/privacy.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     [monad (#+ Monad)]]
diff --git a/stdlib/source/lux/control/state.lux b/stdlib/source/lux/control/state.lux
index fc017f177..b4e958c6b 100644
--- a/stdlib/source/lux/control/state.lux
+++ b/stdlib/source/lux/control/state.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     [monad (#+ Monad do)]]])
diff --git a/stdlib/source/lux/control/thread.lux b/stdlib/source/lux/control/thread.lux
index c4625d6f5..e74dc1eb5 100644
--- a/stdlib/source/lux/control/thread.lux
+++ b/stdlib/source/lux/control/thread.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     [monad (#+ Monad do)]]
diff --git a/stdlib/source/lux/control/writer.lux b/stdlib/source/lux/control/writer.lux
index 278fc9236..bbca0faa0 100644
--- a/stdlib/source/lux/control/writer.lux
+++ b/stdlib/source/lux/control/writer.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     monoid
     ["." functor (#+ Functor)]
     [apply (#+ Apply)]
diff --git a/stdlib/source/lux/data/bit.lux b/stdlib/source/lux/data/bit.lux
index 72cfc096e..8c1b1d1b3 100644
--- a/stdlib/source/lux/data/bit.lux
+++ b/stdlib/source/lux/data/bit.lux
@@ -1,27 +1,34 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monoid (#+ Monoid)]
     [equivalence (#+ Equivalence)]
     hash
     [codec (#+ Codec)]]
-   function])
+   ["." function]])
 
-(structure: #export equivalence (Equivalence Bit)
+(structure: #export equivalence
+  (Equivalence Bit)
+  
   (def: (= x y)
     (if x
       y
       (not y))))
 
-(structure: #export hash (Hash Bit)
+(structure: #export hash
+  (Hash Bit)
+  
   (def: &equivalence ..equivalence)
+  
   (def: (hash value)
     (case value
       #1 1
       #0 0)))
 
 (template [<name> <identity> <op>]
-  [(structure: #export <name> (Monoid Bit)
+  [(structure: #export <name>
+     (Monoid Bit)
+     
      (def: identity <identity>)
      (def: (compose x y) (<op> x y)))]
 
@@ -45,4 +52,4 @@
   {#.doc (doc "Generates the complement of a predicate."
               "That is a predicate that returns the oposite of the original predicate.")}
   (All [a] (-> (-> a Bit) (-> a Bit)))
-  (compose not))
+  (function.compose not))
diff --git a/stdlib/source/lux/data/collection/array.lux b/stdlib/source/lux/data/collection/array.lux
index 55e0ceb2b..946b6a3b4 100644
--- a/stdlib/source/lux/data/collection/array.lux
+++ b/stdlib/source/lux/data/collection/array.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monoid (#+ Monoid)]
     [functor (#+ Functor)]
     [equivalence (#+ Equivalence)]
diff --git a/stdlib/source/lux/data/collection/bits.lux b/stdlib/source/lux/data/collection/bits.lux
index 95732fe15..0e5f7a16e 100644
--- a/stdlib/source/lux/data/collection/bits.lux
+++ b/stdlib/source/lux/data/collection/bits.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux (#- not and or)
+   [abstract
+    [equivalence (#+ Equivalence)]]
    [control
-    [equivalence (#+ Equivalence)]
     pipe]
    [data
     ["." maybe]
diff --git a/stdlib/source/lux/data/collection/dictionary.lux b/stdlib/source/lux/data/collection/dictionary.lux
index a9c53ea18..3580b0ddd 100644
--- a/stdlib/source/lux/data/collection/dictionary.lux
+++ b/stdlib/source/lux/data/collection/dictionary.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [hash (#+ Hash)]
     [equivalence (#+ Equivalence)]
     [functor (#+ Functor)]]
diff --git a/stdlib/source/lux/data/collection/dictionary/ordered.lux b/stdlib/source/lux/data/collection/dictionary/ordered.lux
index 5bd957364..58026984f 100644
--- a/stdlib/source/lux/data/collection/dictionary/ordered.lux
+++ b/stdlib/source/lux/data/collection/dictionary/ordered.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monad (#+ Monad do)]
     equivalence
     [order (#+ Order)]]
diff --git a/stdlib/source/lux/data/collection/list.lux b/stdlib/source/lux/data/collection/list.lux
index b2da3337b..bf4661ad4 100644
--- a/stdlib/source/lux/data/collection/list.lux
+++ b/stdlib/source/lux/data/collection/list.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monoid (#+ Monoid)]
     ["." functor (#+ Functor)]
     [apply (#+ Apply)]
diff --git a/stdlib/source/lux/data/collection/queue.lux b/stdlib/source/lux/data/collection/queue.lux
index 699440648..026190f2b 100644
--- a/stdlib/source/lux/data/collection/queue.lux
+++ b/stdlib/source/lux/data/collection/queue.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [functor (#+ Functor)]]
    [data
diff --git a/stdlib/source/lux/data/collection/queue/priority.lux b/stdlib/source/lux/data/collection/queue/priority.lux
index 1e7d40022..34a87e51d 100644
--- a/stdlib/source/lux/data/collection/queue/priority.lux
+++ b/stdlib/source/lux/data/collection/queue/priority.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [monad (#+ do Monad)]]
    [data
diff --git a/stdlib/source/lux/data/collection/row.lux b/stdlib/source/lux/data/collection/row.lux
index d56da4b79..2dc45312f 100644
--- a/stdlib/source/lux/data/collection/row.lux
+++ b/stdlib/source/lux/data/collection/row.lux
@@ -1,14 +1,15 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
-    [monad (#+ do Monad)]
+    [monad (#+ Monad do)]
     [equivalence (#+ Equivalence)]
-    monoid
-    fold
-    ["p" parser]
+    [monoid (#+ Monoid)]
+    [fold (#+ Fold)]
     [predicate (#+ Predicate)]]
+   [control
+    ["p" parser]]
    [data
     ["." maybe]
     ["." product]
@@ -338,7 +339,7 @@
 (syntax: #export (row {elems (p.some s.any)})
   {#.doc (doc "Row literals."
               (row +10 +20 +30 +40))}
-  (wrap (list (` (from-list (list (~+ elems)))))))
+  (wrap (list (` (..from-list (list (~+ elems)))))))
 
 (structure: #export (node-equivalence Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Node a))))
   (def: (= v1 v2)
diff --git a/stdlib/source/lux/data/collection/sequence.lux b/stdlib/source/lux/data/collection/sequence.lux
index 720515c2d..07735cc26 100644
--- a/stdlib/source/lux/data/collection/sequence.lux
+++ b/stdlib/source/lux/data/collection/sequence.lux
@@ -1,9 +1,10 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
-    [comonad (#+ CoMonad)]
-    ["." continuation (#+ pending Cont)]
+    [comonad (#+ CoMonad)]]
+   [control
+    ["." continuation (#+ Cont pending)]
     ["p" parser]]
    [macro (#+ with-gensyms)
     ["." code]
diff --git a/stdlib/source/lux/data/collection/set.lux b/stdlib/source/lux/data/collection/set.lux
index 5ab374b84..4c764b818 100644
--- a/stdlib/source/lux/data/collection/set.lux
+++ b/stdlib/source/lux/data/collection/set.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [predicate (#+ Predicate)]
     [monoid (#+ Monoid)]
diff --git a/stdlib/source/lux/data/collection/set/multi.lux b/stdlib/source/lux/data/collection/set/multi.lux
index 012224e31..c11d4c558 100644
--- a/stdlib/source/lux/data/collection/set/multi.lux
+++ b/stdlib/source/lux/data/collection/set/multi.lux
@@ -1,7 +1,7 @@
 ## https://en.wikipedia.org/wiki/Multiset
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [hash (#+ Hash)]]
    ["." function]
diff --git a/stdlib/source/lux/data/collection/set/ordered.lux b/stdlib/source/lux/data/collection/set/ordered.lux
index 4d607ce15..4f814c1ea 100644
--- a/stdlib/source/lux/data/collection/set/ordered.lux
+++ b/stdlib/source/lux/data/collection/set/ordered.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [order (#+ Order)]]
    [data
diff --git a/stdlib/source/lux/data/collection/stack.lux b/stdlib/source/lux/data/collection/stack.lux
index d3a937cb4..089398ca5 100644
--- a/stdlib/source/lux/data/collection/stack.lux
+++ b/stdlib/source/lux/data/collection/stack.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [functor (#+ Functor)]]
    [data
diff --git a/stdlib/source/lux/data/collection/tree/finger.lux b/stdlib/source/lux/data/collection/tree/finger.lux
index e3aed3b0d..f35129dff 100644
--- a/stdlib/source/lux/data/collection/tree/finger.lux
+++ b/stdlib/source/lux/data/collection/tree/finger.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["m" monoid]
     [predicate (#+ Predicate)]]
    [data
diff --git a/stdlib/source/lux/data/collection/tree/rose.lux b/stdlib/source/lux/data/collection/tree/rose.lux
index 97cb840fb..ad64b72ed 100644
--- a/stdlib/source/lux/data/collection/tree/rose.lux
+++ b/stdlib/source/lux/data/collection/tree/rose.lux
@@ -1,11 +1,12 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     functor
     [monad (#+ do Monad)]
     equivalence
-    ["p" parser]
     fold]
+   [control
+    ["p" parser]]
    [data
     [collection
      ["." list ("#@." monad fold)]]]
diff --git a/stdlib/source/lux/data/collection/tree/rose/zipper.lux b/stdlib/source/lux/data/collection/tree/rose/zipper.lux
index 1a8ed4d5c..bac8961e3 100644
--- a/stdlib/source/lux/data/collection/tree/rose/zipper.lux
+++ b/stdlib/source/lux/data/collection/tree/rose/zipper.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     functor
     comonad
     [equivalence (#+ Equivalence)]]
diff --git a/stdlib/source/lux/data/color.lux b/stdlib/source/lux/data/color.lux
index bd02c4087..60b87ab61 100644
--- a/stdlib/source/lux/data/color.lux
+++ b/stdlib/source/lux/data/color.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]]
    [data
     [number
diff --git a/stdlib/source/lux/data/env.lux b/stdlib/source/lux/data/env.lux
index 2c8d01fcd..7e4265e6a 100644
--- a/stdlib/source/lux/data/env.lux
+++ b/stdlib/source/lux/data/env.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     comonad]])
 
diff --git a/stdlib/source/lux/data/error.lux b/stdlib/source/lux/data/error.lux
index 3e7369ed3..c730ee5a5 100644
--- a/stdlib/source/lux/data/error.lux
+++ b/stdlib/source/lux/data/error.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." functor (#+ Functor)]
     [apply (#+ Apply)]
     ["." monad (#+ Monad do)]
@@ -10,7 +10,9 @@
   (#Failure Text)
   (#Success a))
 
-(structure: #export functor (Functor Error)
+(structure: #export functor
+  (Functor Error)
+  
   (def: (map f ma)
     (case ma
       (#Failure msg)
@@ -19,7 +21,9 @@
       (#Success datum)
       (#Success (f datum)))))
 
-(structure: #export apply (Apply Error)
+(structure: #export apply
+  (Apply Error)
+  
   (def: &functor ..functor)
 
   (def: (apply ff fa)
@@ -36,7 +40,9 @@
       (#Failure msg))
     ))
 
-(structure: #export monad (Monad Error)
+(structure: #export monad
+  (Monad Error)
+  
   (def: &functor ..functor)
 
   (def: (wrap a)
@@ -74,6 +80,7 @@
 
 (structure: #export (equivalence (^open ",@."))
   (All [a] (-> (Equivalence a) (Equivalence (Error a))))
+
   (def: (= reference sample)
     (case [reference sample]
       [(#Success reference) (#Success sample)]
diff --git a/stdlib/source/lux/data/format/binary.lux b/stdlib/source/lux/data/format/binary.lux
index b794fe029..771d9f693 100644
--- a/stdlib/source/lux/data/format/binary.lux
+++ b/stdlib/source/lux/data/format/binary.lux
@@ -1,12 +1,13 @@
 (.module:
   [lux (#- and or nat int rev list type)
-   [control
+   [abstract
     [monoid (#+ Monoid)]
     ["." fold]
-    [monad (#+ do Monad)]
-    ["." parser (#+ Parser) ("#;." functor)]
-    ["ex" exception (#+ exception:)]
+    [monad (#+ Monad do)]
     [equivalence (#+ Equivalence)]]
+   [control
+    ["." parser (#+ Parser) ("#;." functor)]
+    ["ex" exception (#+ exception:)]]
    [data
     ["." error (#+ Error)]
     [number
diff --git a/stdlib/source/lux/data/format/context.lux b/stdlib/source/lux/data/format/context.lux
index a89675393..6ef06085f 100644
--- a/stdlib/source/lux/data/format/context.lux
+++ b/stdlib/source/lux/data/format/context.lux
@@ -1,9 +1,10 @@
 (.module:
   [lux #*
+   [abstract
+    [monad (#+ do)]]
    [control
     [parser (#+ Parser)]
-    ["ex" exception (#+ exception:)]
-    [monad (#+ do)]]
+    ["ex" exception (#+ exception:)]]
    [data
     ["." error (#+ Error)]
     ["." text
diff --git a/stdlib/source/lux/data/format/json.lux b/stdlib/source/lux/data/format/json.lux
index b03cb5ae9..34fcf4dfb 100644
--- a/stdlib/source/lux/data/format/json.lux
+++ b/stdlib/source/lux/data/format/json.lux
@@ -1,11 +1,12 @@
 (.module: {#.doc (.doc "Functionality for reading and writing values in the JSON format."
                        "For more information, please see: http://www.json.org/")}
   [lux #*
-   [control
-    pipe
+   [abstract
     ["." monad (#+ Monad do)]
     [equivalence (#+ Equivalence)]
-    codec
+    codec]
+   [control
+    pipe
     ["p" parser (#+ Parser) ("#@." monad)]
     ["ex" exception (#+ exception:)]]
    [data
diff --git a/stdlib/source/lux/data/format/xml.lux b/stdlib/source/lux/data/format/xml.lux
index 85081f86c..6cd469e04 100644
--- a/stdlib/source/lux/data/format/xml.lux
+++ b/stdlib/source/lux/data/format/xml.lux
@@ -1,9 +1,10 @@
 (.module: {#.doc "Functionality for reading, generating and processing values in the XML format."}
   [lux #*
-   [control
+   [abstract
     monad
     [equivalence (#+ Equivalence)]
-    codec
+    codec]
+   [control
     ["p" parser ("#;." monad)]
     ["ex" exception (#+ exception:)]]
    [data
diff --git a/stdlib/source/lux/data/identity.lux b/stdlib/source/lux/data/identity.lux
index 7793bd7f5..ff464a6f8 100644
--- a/stdlib/source/lux/data/identity.lux
+++ b/stdlib/source/lux/data/identity.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     [monad (#+ Monad)]
diff --git a/stdlib/source/lux/data/lazy.lux b/stdlib/source/lux/data/lazy.lux
index dc889675a..82cd8ec51 100644
--- a/stdlib/source/lux/data/lazy.lux
+++ b/stdlib/source/lux/data/lazy.lux
@@ -1,11 +1,12 @@
 (.module:
   [lux #*
    ["." io]
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     [monad (#+ Monad do)]
-    [equivalence (#+ Equivalence)]
+    [equivalence (#+ Equivalence)]]
+   [control
     [concurrency
      ["." atom]]]
    [macro (#+ with-gensyms)
diff --git a/stdlib/source/lux/data/maybe.lux b/stdlib/source/lux/data/maybe.lux
index e00b89234..b96e014b3 100644
--- a/stdlib/source/lux/data/maybe.lux
+++ b/stdlib/source/lux/data/maybe.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monoid (#+ Monoid)]
     ["." functor (#+ Functor)]
     [apply (#+ Apply)]
diff --git a/stdlib/source/lux/data/name.lux b/stdlib/source/lux/data/name.lux
index 286071169..59e004ea7 100644
--- a/stdlib/source/lux/data/name.lux
+++ b/stdlib/source/lux/data/name.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [codec (#+ Codec)]
     hash]
diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux
index e6b169fc4..0577258ca 100644
--- a/stdlib/source/lux/data/number.lux
+++ b/stdlib/source/lux/data/number.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [codec (#+ Codec)]]
    [data
     ["." error (#+ Error)]
diff --git a/stdlib/source/lux/data/number/complex.lux b/stdlib/source/lux/data/number/complex.lux
index d8334d104..6c057ffb1 100644
--- a/stdlib/source/lux/data/number/complex.lux
+++ b/stdlib/source/lux/data/number/complex.lux
@@ -1,11 +1,12 @@
 (.module: {#.doc "Complex arithmetic."}
   [lux #*
    ["." math]
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     number
     codec
-    ["M" monad (#+ Monad do)]
+    ["M" monad (#+ Monad do)]]
+   [control
     ["p" parser]]
    [data
     ["." maybe]
diff --git a/stdlib/source/lux/data/number/frac.lux b/stdlib/source/lux/data/number/frac.lux
index f49f73039..790aee05b 100644
--- a/stdlib/source/lux/data/number/frac.lux
+++ b/stdlib/source/lux/data/number/frac.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [hash (#+ Hash)]
     [number (#+ Number)]
     [monoid (#+ Monoid)]
diff --git a/stdlib/source/lux/data/number/i64.lux b/stdlib/source/lux/data/number/i64.lux
index ffce20b4c..dbc58b004 100644
--- a/stdlib/source/lux/data/number/i64.lux
+++ b/stdlib/source/lux/data/number/i64.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux (#- and or not)
-   [control
+   [abstract
     [monoid (#+ Monoid)]]])
 
 (def: #export bits-per-byte 8)
diff --git a/stdlib/source/lux/data/number/int.lux b/stdlib/source/lux/data/number/int.lux
index f94049296..22b7aff23 100644
--- a/stdlib/source/lux/data/number/int.lux
+++ b/stdlib/source/lux/data/number/int.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [hash (#+ Hash)]
     [number (#+ Number)]
     [enum (#+ Enum)]
diff --git a/stdlib/source/lux/data/number/nat.lux b/stdlib/source/lux/data/number/nat.lux
index c1f0ca420..5ca294df5 100644
--- a/stdlib/source/lux/data/number/nat.lux
+++ b/stdlib/source/lux/data/number/nat.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [hash (#+ Hash)]
     [number (#+ Number)]
     [enum (#+ Enum)]
diff --git a/stdlib/source/lux/data/number/ratio.lux b/stdlib/source/lux/data/number/ratio.lux
index 49ce1f194..a501f9a1b 100644
--- a/stdlib/source/lux/data/number/ratio.lux
+++ b/stdlib/source/lux/data/number/ratio.lux
@@ -1,12 +1,13 @@
 (.module: {#.doc "Rational numbers."}
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [order (#+ Order)]
     [monoid (#+ Monoid)]
-    number
-    codec
-    monad
+    [number (#+ Number)]
+    [codec (#+ Codec)]
+    [monad (#+ do)]]
+   [control
     ["p" parser]]
    [data
     ["." error]
diff --git a/stdlib/source/lux/data/number/rev.lux b/stdlib/source/lux/data/number/rev.lux
index bbb34c570..4738a72a0 100644
--- a/stdlib/source/lux/data/number/rev.lux
+++ b/stdlib/source/lux/data/number/rev.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [hash (#+ Hash)]
     [number (#+ Number)]
     [enum (#+ Enum)]
diff --git a/stdlib/source/lux/data/store.lux b/stdlib/source/lux/data/store.lux
index 69ad7d734..36cc3e67d 100644
--- a/stdlib/source/lux/data/store.lux
+++ b/stdlib/source/lux/data/store.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     comonad]
    [type
diff --git a/stdlib/source/lux/data/text.lux b/stdlib/source/lux/data/text.lux
index 384d4e860..bf40c3ef7 100644
--- a/stdlib/source/lux/data/text.lux
+++ b/stdlib/source/lux/data/text.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monoid (#+ Monoid)]
     [equivalence (#+ Equivalence)]
     [order (#+ Order)]
@@ -25,18 +25,18 @@
   (-> Char Text)
   (|>> (:coerce Int) "lux int char"))
 
-(template [<name> <code>]
+(template [<code> <name>]
   [(def: #export <name> (from-code <code>))]
 
-  [null 0]
-  [alarm 7]
-  [back-space 8]
-  [tab 9]
-  [new-line 10]
-  [vertical-tab 11]
-  [form-feed 12]
-  [carriage-return 13]
-  [double-quote 34]
+  [00 null]
+  [07 alarm]
+  [08 back-space]
+  [09 tab]
+  [10 new-line]
+  [11 vertical-tab]
+  [12 form-feed]
+  [13 carriage-return]
+  [34 double-quote]
   )
 
 (def: #export (size x)
diff --git a/stdlib/source/lux/data/text/encoding.lux b/stdlib/source/lux/data/text/encoding.lux
index 8f59bd530..b4372471c 100644
--- a/stdlib/source/lux/data/text/encoding.lux
+++ b/stdlib/source/lux/data/text/encoding.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [codec (#+ Codec)]]
    [data
     ["." error (#+ Error)]]
diff --git a/stdlib/source/lux/data/text/format.lux b/stdlib/source/lux/data/text/format.lux
index 0becf8633..a204e567b 100644
--- a/stdlib/source/lux/data/text/format.lux
+++ b/stdlib/source/lux/data/text/format.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["p" parser]]
    [data
     ["." bit]
diff --git a/stdlib/source/lux/data/text/lexer.lux b/stdlib/source/lux/data/text/lexer.lux
index e5f19edf6..531d2ae64 100644
--- a/stdlib/source/lux/data/text/lexer.lux
+++ b/stdlib/source/lux/data/text/lexer.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux (#- or and not)
+   [abstract
+    [monad (#+ do Monad)]]
    [control
-    [monad (#+ do Monad)]
     ["p" parser]
     ["ex" exception (#+ exception:)]]
    [data
diff --git a/stdlib/source/lux/data/text/regex.lux b/stdlib/source/lux/data/text/regex.lux
index b94dbb73a..5e867b9b6 100644
--- a/stdlib/source/lux/data/text/regex.lux
+++ b/stdlib/source/lux/data/text/regex.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    monad]
    [control
-    monad
     ["p" parser ("#@." monad)]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/data/text/unicode.lux b/stdlib/source/lux/data/text/unicode.lux
index 11a98b358..a6fd13ebc 100644
--- a/stdlib/source/lux/data/text/unicode.lux
+++ b/stdlib/source/lux/data/text/unicode.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." interval (#+ Interval)]
     [monoid (#+ Monoid)]]
    [data
diff --git a/stdlib/source/lux/data/trace.lux b/stdlib/source/lux/data/trace.lux
index 055d1758c..94e02ea6b 100644
--- a/stdlib/source/lux/data/trace.lux
+++ b/stdlib/source/lux/data/trace.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." monoid (#+ Monoid)]
     [functor (#+ Functor)]
     comonad]
diff --git a/stdlib/source/lux/function.lux b/stdlib/source/lux/function.lux
index 65202e361..5a33a2aae 100644
--- a/stdlib/source/lux/function.lux
+++ b/stdlib/source/lux/function.lux
@@ -1,13 +1,14 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monoid (#+ Monoid)]]])
 
 (def: #export identity
   {#.doc (doc "Identity function."
               "Does nothing to it's argument and just returns it."
-              (= (identity "foo")
-                 "foo"))}
+              (let [value "foo"]
+                (is? (identity value)
+                     value)))}
   (All [a] (-> a a))
   (|>>))
 
diff --git a/stdlib/source/lux/host.js.lux b/stdlib/source/lux/host.js.lux
index bf24adc38..aec050642 100644
--- a/stdlib/source/lux/host.js.lux
+++ b/stdlib/source/lux/host.js.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    monad]
    [control
-    monad
     ["p" parser]]
    [data
     [collection
diff --git a/stdlib/source/lux/host.jvm.lux b/stdlib/source/lux/host.jvm.lux
index e4891f56b..b829e21c9 100644
--- a/stdlib/source/lux/host.jvm.lux
+++ b/stdlib/source/lux/host.jvm.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux (#- type)
+   [abstract
+    ["." monad (#+ Monad do)]
+    ["." enum]]
    [control
-    ["." monad (#+ do Monad)]
-    ["." enum]
     ["p" parser]]
    [data
     ["." maybe]
diff --git a/stdlib/source/lux/host/jvm/attribute.lux b/stdlib/source/lux/host/jvm/attribute.lux
index 1bef206da..bcd3a3734 100644
--- a/stdlib/source/lux/host/jvm/attribute.lux
+++ b/stdlib/source/lux/host/jvm/attribute.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux (#- Info Code' Code)
-   [control
+   [abstract
     ["." equivalence (#+ Equivalence)]
-    [monad (#+ do)]
+    [monad (#+ do)]]
+   [control
     ["." state (#+ State)]]
    [data
     [format
diff --git a/stdlib/source/lux/host/jvm/class.lux b/stdlib/source/lux/host/jvm/class.lux
index 2474ffa69..6fb6f48d4 100644
--- a/stdlib/source/lux/host/jvm/class.lux
+++ b/stdlib/source/lux/host/jvm/class.lux
@@ -1,10 +1,11 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." equivalence (#+ Equivalence)]
     [monoid (#+)]
+    ["." monad (#+ do)]]
+   [control
     [parser (#+)]
-    ["." monad (#+ do)]
     ["." state (#+ State)]]
    [data
     [number (#+)
diff --git a/stdlib/source/lux/host/jvm/constant.lux b/stdlib/source/lux/host/jvm/constant.lux
index d9fcc2731..3af24af55 100644
--- a/stdlib/source/lux/host/jvm/constant.lux
+++ b/stdlib/source/lux/host/jvm/constant.lux
@@ -1,9 +1,10 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monad (#+ do)]
-    ["." parser]
     ["." equivalence (#+ Equivalence)]]
+   [control
+    ["." parser]]
    [data
     [number
      ["." int]
diff --git a/stdlib/source/lux/host/jvm/constant/pool.lux b/stdlib/source/lux/host/jvm/constant/pool.lux
index 846c0fa18..a304d5ac4 100644
--- a/stdlib/source/lux/host/jvm/constant/pool.lux
+++ b/stdlib/source/lux/host/jvm/constant/pool.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." equivalence (#+ Equivalence)]
-    [monad (#+ do)]
+    [monad (#+ do)]]
+   [control
     ["." state (#+ State)]]
    [data
     ["." text ("#;." equivalence)]
diff --git a/stdlib/source/lux/host/jvm/constant/tag.lux b/stdlib/source/lux/host/jvm/constant/tag.lux
index 0339489f9..71e75f40b 100644
--- a/stdlib/source/lux/host/jvm/constant/tag.lux
+++ b/stdlib/source/lux/host/jvm/constant/tag.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]]
    [data
     [format
diff --git a/stdlib/source/lux/host/jvm/encoding.lux b/stdlib/source/lux/host/jvm/encoding.lux
index 7d7fb636d..33ac427c2 100644
--- a/stdlib/source/lux/host/jvm/encoding.lux
+++ b/stdlib/source/lux/host/jvm/encoding.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    [equivalence (#+ Equivalence)]]
    [control
-    [equivalence (#+ Equivalence)]
     ["." parser ("#;." functor)]]
    [data
     [number
diff --git a/stdlib/source/lux/host/jvm/field.lux b/stdlib/source/lux/host/jvm/field.lux
index f40800790..930ca97d8 100644
--- a/stdlib/source/lux/host/jvm/field.lux
+++ b/stdlib/source/lux/host/jvm/field.lux
@@ -1,10 +1,11 @@
 (.module:
   [lux (#- static)
-   [control
+   [abstract
     ["." equivalence (#+ Equivalence)]
     [monoid (#+)]
+    ["." monad (#+ do)]]
+   [control
     [parser (#+)]
-    ["." monad (#+ do)]
     ["." state (#+ State)]]
    [data
     [number (#+)
diff --git a/stdlib/source/lux/host/jvm/index.lux b/stdlib/source/lux/host/jvm/index.lux
index c7174f9d4..3a425dd32 100644
--- a/stdlib/source/lux/host/jvm/index.lux
+++ b/stdlib/source/lux/host/jvm/index.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." equivalence (#+ Equivalence)]]
    [data
     [format
diff --git a/stdlib/source/lux/host/jvm/loader.jvm.lux b/stdlib/source/lux/host/jvm/loader.jvm.lux
index 03edd60cf..22e8a8352 100644
--- a/stdlib/source/lux/host/jvm/loader.jvm.lux
+++ b/stdlib/source/lux/host/jvm/loader.jvm.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["ex" exception (#+ exception:)]
     [concurrency
      ["." atom (#+ Atom)]]]
diff --git a/stdlib/source/lux/host/jvm/method.lux b/stdlib/source/lux/host/jvm/method.lux
index e0ef63d3e..e4f3cdea2 100644
--- a/stdlib/source/lux/host/jvm/method.lux
+++ b/stdlib/source/lux/host/jvm/method.lux
@@ -1,10 +1,11 @@
 (.module:
   [lux (#- static)
-   [control
+   [abstract
     ["." equivalence (#+ Equivalence)]
     [monoid (#+)]
+    ["." monad (#+ do)]]
+   [control
     [parser (#+)]
-    ["." monad (#+ do)]
     ["." state (#+ State)]]
    [data
     [number (#+)
diff --git a/stdlib/source/lux/host/jvm/modifier.lux b/stdlib/source/lux/host/jvm/modifier.lux
index e25e14b78..ac8d1b201 100644
--- a/stdlib/source/lux/host/jvm/modifier.lux
+++ b/stdlib/source/lux/host/jvm/modifier.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." equivalence]
-    ["." monoid]
+    ["." monoid]]
+   [control
     ["." parser]]
    [data
     ["." number
diff --git a/stdlib/source/lux/host/jvm/modifier/inner.lux b/stdlib/source/lux/host/jvm/modifier/inner.lux
index 9f57965d0..2980ef6e4 100644
--- a/stdlib/source/lux/host/jvm/modifier/inner.lux
+++ b/stdlib/source/lux/host/jvm/modifier/inner.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux (#- static)
-   [control
+   [abstract
     [equivalence (#+)]
-    [monoid (#+)]
+    [monoid (#+)]]
+   [control
     [parser (#+)]]
    [data
     [number (#+)
diff --git a/stdlib/source/lux/io.lux b/stdlib/source/lux/io.lux
index 4da9fe897..4102ff9c4 100644
--- a/stdlib/source/lux/io.lux
+++ b/stdlib/source/lux/io.lux
@@ -1,6 +1,6 @@
 (.module: {#.doc "A method for abstracting I/O and effectful computations to make it safe while writing pure functional code."}
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     [monad (#+ Monad do)]]
diff --git a/stdlib/source/lux/locale.lux b/stdlib/source/lux/locale.lux
index 3d0f3e532..1d6a4385f 100644
--- a/stdlib/source/lux/locale.lux
+++ b/stdlib/source/lux/locale.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [hash (#+ Hash)]]
    [data
diff --git a/stdlib/source/lux/locale/language.lux b/stdlib/source/lux/locale/language.lux
index 1cfa9dd82..dbda89f73 100644
--- a/stdlib/source/lux/locale/language.lux
+++ b/stdlib/source/lux/locale/language.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [hash (#+ Hash)]]
    [data
diff --git a/stdlib/source/lux/locale/territory.lux b/stdlib/source/lux/locale/territory.lux
index b37148bb2..dfd06f8c8 100644
--- a/stdlib/source/lux/locale/territory.lux
+++ b/stdlib/source/lux/locale/territory.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [hash (#+ Hash)]]
    [data
diff --git a/stdlib/source/lux/macro.lux b/stdlib/source/lux/macro.lux
index 059351420..a3014c649 100644
--- a/stdlib/source/lux/macro.lux
+++ b/stdlib/source/lux/macro.lux
@@ -1,6 +1,6 @@
 (.module: {#.doc "Functions for extracting information from the state of the compiler."}
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     ["." monad (#+ Monad do)]]
diff --git a/stdlib/source/lux/macro/code.lux b/stdlib/source/lux/macro/code.lux
index 84f08e5f1..ae7ba555c 100644
--- a/stdlib/source/lux/macro/code.lux
+++ b/stdlib/source/lux/macro/code.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux (#- nat int rev)
-   [control
+   [abstract
     ["." equivalence (#+ Equivalence)]]
    [data
     ["." bit]
diff --git a/stdlib/source/lux/macro/poly.lux b/stdlib/source/lux/macro/poly.lux
index 4f5cd09a0..31b293144 100644
--- a/stdlib/source/lux/macro/poly.lux
+++ b/stdlib/source/lux/macro/poly.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux (#- function)
-   [control
+   [abstract
     ["." monad (#+ Monad do)]
-    [equivalence]
+    [equivalence]]
+   [control
     ["p" parser]
     ["ex" exception (#+ exception:)]]
    ["." function]
diff --git a/stdlib/source/lux/macro/poly/equivalence.lux b/stdlib/source/lux/macro/poly/equivalence.lux
index cc0b79234..c39ad9412 100644
--- a/stdlib/source/lux/macro/poly/equivalence.lux
+++ b/stdlib/source/lux/macro/poly/equivalence.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux #*
+   [abstract
+    [monad (#+ Monad do)]
+    ["/" equivalence]]
    [control
-    [monad (#+ do Monad)]
-    ["eq" equivalence]
     ["p" parser]]
    [data
     ["." product]
@@ -45,7 +46,7 @@
          inputT poly.peek
          #let [@Equivalence (: (-> Type Code)
                                (function (_ type)
-                                 (` ((~! eq.Equivalence) (~ (poly.to-code *env* type))))))]]
+                                 (` ((~! /.Equivalence) (~ (poly.to-code *env* type))))))]]
         ($_ p.either
             ## Basic types
             (~~ (template [<matcher> <eq>]
@@ -135,8 +136,8 @@
               [[g!self bodyC] (poly.recursive equivalence)
                #let [g!_ (code.local-identifier "_____________")]]
               (wrap (` (: (~ (@Equivalence inputT))
-                          ((~! eq.rec) (.function ((~ g!_) (~ g!self))
-                                         (~ bodyC)))))))
+                          ((~! /.rec) (.function ((~ g!_) (~ g!self))
+                                        (~ bodyC)))))))
             poly.recursive-self
             ## Type applications
             (do @
@@ -148,8 +149,8 @@
             (do @
               [[funcC varsC bodyC] (poly.polymorphic equivalence)]
               (wrap (` (: (All [(~+ varsC)]
-                            (-> (~+ (list@map (|>> (~) ((~! eq.Equivalence)) (`)) varsC))
-                                ((~! eq.Equivalence) ((~ (poly.to-code *env* inputT)) (~+ varsC)))))
+                            (-> (~+ (list@map (|>> (~) ((~! /.Equivalence)) (`)) varsC))
+                                ((~! /.Equivalence) ((~ (poly.to-code *env* inputT)) (~+ varsC)))))
                           (function ((~ funcC) (~+ varsC))
                             (~ bodyC))))))
             poly.recursive-call
diff --git a/stdlib/source/lux/macro/poly/functor.lux b/stdlib/source/lux/macro/poly/functor.lux
index 6252378eb..947f08ac8 100644
--- a/stdlib/source/lux/macro/poly/functor.lux
+++ b/stdlib/source/lux/macro/poly/functor.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux #*
+   [abstract
+    [monad (#+ Monad do)]
+    ["." functor]]
    [control
-    [monad (#+ do Monad)]
-    ["." functor]
     ["p" parser]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/macro/poly/json.lux b/stdlib/source/lux/macro/poly/json.lux
index cc5f3b5c9..f397de2a2 100644
--- a/stdlib/source/lux/macro/poly/json.lux
+++ b/stdlib/source/lux/macro/poly/json.lux
@@ -1,9 +1,10 @@
 (.module: {#.doc "Codecs for values in the JSON format."}
   [lux #*
-   [control
+   [abstract
     [monad (#+ Monad do)]
     [equivalence (#+ Equivalence)]
-    ["." codec]
+    ["." codec]]
+   [control
     ["p" parser]]
    [data
     ["." bit]
diff --git a/stdlib/source/lux/macro/syntax.lux b/stdlib/source/lux/macro/syntax.lux
index 08bb3c978..90d8b0938 100644
--- a/stdlib/source/lux/macro/syntax.lux
+++ b/stdlib/source/lux/macro/syntax.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux (#- nat int rev)
-   [control
+   [abstract
     ["." monad (#+ Monad do)]
-    [equivalence (#+ Equivalence)]
+    [equivalence (#+ Equivalence)]]
+   [control
     ["p" parser]]
    [data
     ["." bit]
diff --git a/stdlib/source/lux/macro/syntax/common/reader.lux b/stdlib/source/lux/macro/syntax/common/reader.lux
index 6ad2e4d46..99277857f 100644
--- a/stdlib/source/lux/macro/syntax/common/reader.lux
+++ b/stdlib/source/lux/macro/syntax/common/reader.lux
@@ -1,7 +1,8 @@
 (.module: {#.doc "Commons syntax readers."}
   [lux #*
+   [abstract
+    monad]
    [control
-    monad
     ["p" parser ("#;." monad)]]
    [data
     ["." name ("#;." equivalence)]
diff --git a/stdlib/source/lux/macro/template.lux b/stdlib/source/lux/macro/template.lux
index a69d656f6..ad1600856 100644
--- a/stdlib/source/lux/macro/template.lux
+++ b/stdlib/source/lux/macro/template.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    ["." monad (#+ do)]]
    [control
-    ["." monad (#+ do)]
     ["p" parser ("#@." functor)]]
    [data
     ["." bit ("#@." codec)]
diff --git a/stdlib/source/lux/math/infix.lux b/stdlib/source/lux/math/infix.lux
index e2cfc455c..ecb309d13 100644
--- a/stdlib/source/lux/math/infix.lux
+++ b/stdlib/source/lux/math/infix.lux
@@ -1,7 +1,8 @@
 (.module: {#.doc "Common mathematical constants and functions."}
   [lux #*
+   [abstract
+    monad]
    [control
-    monad
     ["p" parser ("#;." functor)]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/math/logic/fuzzy.lux b/stdlib/source/lux/math/logic/fuzzy.lux
index 99bc2f8db..f27c51ec7 100644
--- a/stdlib/source/lux/math/logic/fuzzy.lux
+++ b/stdlib/source/lux/math/logic/fuzzy.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [predicate (#+ Predicate)]]
    [data
     [collection
diff --git a/stdlib/source/lux/math/modular.lux b/stdlib/source/lux/math/modular.lux
index 866d3c99f..24c7b0e72 100644
--- a/stdlib/source/lux/math/modular.lux
+++ b/stdlib/source/lux/math/modular.lux
@@ -1,10 +1,11 @@
 (.module:
   [lux #*
-   [control
-    ["ex" exception (#+ exception:)]
-    ["p" parser]
+   [abstract
     [codec (#+ Codec)]
     [monad (#+ do)]]
+   [control
+    ["ex" exception (#+ exception:)]
+    ["p" parser]]
    [data
     ["." error (#+ Error)]
     [number
diff --git a/stdlib/source/lux/math/random.lux b/stdlib/source/lux/math/random.lux
index 47ddb7fa2..ef1ed3e37 100644
--- a/stdlib/source/lux/math/random.lux
+++ b/stdlib/source/lux/math/random.lux
@@ -1,6 +1,6 @@
 (.module: {#.doc "Pseudo-random number generation (PRNG) algorithms."}
   [lux (#- or and list i64 nat int rev char)
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
     ["." monad (#+ do Monad)]
diff --git a/stdlib/source/lux/test.lux b/stdlib/source/lux/test.lux
index 9f261dbc8..58d7654d3 100644
--- a/stdlib/source/lux/test.lux
+++ b/stdlib/source/lux/test.lux
@@ -1,7 +1,8 @@
 (.module: {#.doc "Tools for unit & property-based/generative testing."}
   [lux (#- and)
+   [abstract
+    ["." monad (#+ Monad do)]]
    [control
-    ["." monad (#+ Monad do)]
     ["ex" exception (#+ exception:)]
     [concurrency
      ["." promise (#+ Promise) ("#;." monad)]]]
diff --git a/stdlib/source/lux/time/date.lux b/stdlib/source/lux/time/date.lux
index 9ca3b8939..994b95dbe 100644
--- a/stdlib/source/lux/time/date.lux
+++ b/stdlib/source/lux/time/date.lux
@@ -1,12 +1,13 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [order (#+ Order)]
     [enum (#+ Enum)]
     codec
-    ["p" parser ("#@." functor)]
     [monad (#+ do)]]
+   [control
+    ["p" parser ("#@." functor)]]
    [data
     ["." error (#+ Error)]
     ["." maybe]
diff --git a/stdlib/source/lux/time/day.lux b/stdlib/source/lux/time/day.lux
index 53aa37483..87c603937 100644
--- a/stdlib/source/lux/time/day.lux
+++ b/stdlib/source/lux/time/day.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [order (#+ Order)]
     [enum (#+ Enum)]]])
diff --git a/stdlib/source/lux/time/duration.lux b/stdlib/source/lux/time/duration.lux
index cbad3c694..887a074f7 100644
--- a/stdlib/source/lux/time/duration.lux
+++ b/stdlib/source/lux/time/duration.lux
@@ -1,12 +1,13 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     equivalence
     [order (#+ Order)]
     codec
     [monoid (#+ Monoid)]
-    ["p" parser]
     [monad (#+ do)]]
+   [control
+    ["p" parser]]
    [data
     [number
      ["." nat ("#;." decimal)]
diff --git a/stdlib/source/lux/time/instant.lux b/stdlib/source/lux/time/instant.lux
index 4231cc6c1..866616ca1 100644
--- a/stdlib/source/lux/time/instant.lux
+++ b/stdlib/source/lux/time/instant.lux
@@ -1,12 +1,13 @@
 (.module:
   [lux #*
    [io (#+ IO io)]
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [order (#+ Order)]
     [enum (#+ Enum)]
     codec
-    [monad (#+ do Monad)]
+    [monad (#+ do Monad)]]
+   [control
     ["p" parser]]
    [data
     ["." error (#+ Error)]
diff --git a/stdlib/source/lux/time/month.lux b/stdlib/source/lux/time/month.lux
index 2863220da..3911d7849 100644
--- a/stdlib/source/lux/time/month.lux
+++ b/stdlib/source/lux/time/month.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [order (#+ Order)]
     [enum (#+ Enum)]]])
diff --git a/stdlib/source/lux/tool/compiler/analysis.lux b/stdlib/source/lux/tool/compiler/analysis.lux
index c2a6d0cb7..2f173007b 100644
--- a/stdlib/source/lux/tool/compiler/analysis.lux
+++ b/stdlib/source/lux/tool/compiler/analysis.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux (#- nat int rev)
-   [control
+   [abstract
     [monad (#+ do)]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/tool/compiler/meta/archive.lux b/stdlib/source/lux/tool/compiler/meta/archive.lux
index e9ecee8cd..46a6ce0a6 100644
--- a/stdlib/source/lux/tool/compiler/meta/archive.lux
+++ b/stdlib/source/lux/tool/compiler/meta/archive.lux
@@ -1,9 +1,10 @@
 (.module:
   [lux (#- Module)
-   [control
-    ["ex" exception (#+ exception:)]
+   [abstract
     ["." equivalence (#+ Equivalence)]
     ["." monad (#+ do)]]
+   [control
+    ["ex" exception (#+ exception:)]]
    [data
     ["." error (#+ Error)]
     ["." name]
diff --git a/stdlib/source/lux/tool/compiler/meta/archive/signature.lux b/stdlib/source/lux/tool/compiler/meta/archive/signature.lux
index b8b9c43b2..7c9f0cbe2 100644
--- a/stdlib/source/lux/tool/compiler/meta/archive/signature.lux
+++ b/stdlib/source/lux/tool/compiler/meta/archive/signature.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." equivalence (#+ Equivalence)]]
    [data
     ["." name]
diff --git a/stdlib/source/lux/tool/compiler/phase.lux b/stdlib/source/lux/tool/compiler/phase.lux
index 3ae66af16..09657c3cf 100644
--- a/stdlib/source/lux/tool/compiler/phase.lux
+++ b/stdlib/source/lux/tool/compiler/phase.lux
@@ -1,9 +1,10 @@
 (.module:
   [lux #*
+   [abstract
+    [monad (#+ do)]]
    [control
     ["." state]
-    ["ex" exception (#+ Exception exception:)]
-    [monad (#+ do)]]
+    ["ex" exception (#+ Exception exception:)]]
    [data
     ["." product]
     ["." error (#+ Error) ("#;." functor)]
diff --git a/stdlib/source/lux/tool/compiler/phase/extension.lux b/stdlib/source/lux/tool/compiler/phase/extension.lux
index 7ce75f6e5..87e7474d4 100644
--- a/stdlib/source/lux/tool/compiler/phase/extension.lux
+++ b/stdlib/source/lux/tool/compiler/phase/extension.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux (#- Name)
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["ex" exception (#+ exception:)]]
    [data
     ["." error (#+ Error)]
diff --git a/stdlib/source/lux/tool/compiler/phase/extension/bundle.lux b/stdlib/source/lux/tool/compiler/phase/extension/bundle.lux
index ad99db848..28015b956 100644
--- a/stdlib/source/lux/tool/compiler/phase/extension/bundle.lux
+++ b/stdlib/source/lux/tool/compiler/phase/extension/bundle.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monad (#+ do)]]
    [data
     ["." text
diff --git a/stdlib/source/lux/tool/compiler/phase/generation.lux b/stdlib/source/lux/tool/compiler/phase/generation.lux
index f0609d666..3053752fe 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux (#- Module)
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["." exception (#+ exception:)]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/extension.lux b/stdlib/source/lux/tool/compiler/phase/generation/extension.lux
index 681fd35f8..7c08e94cc 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/extension.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/extension.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." monad (#+ do)]]
    [data
     [collection
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js.lux b/stdlib/source/lux/tool/compiler/phase/generation/js.lux
index 29c95ff43..37a8d1bc6 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/js.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/js.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monad (#+ do)]]]
   [/
    [runtime (#+ Phase)]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js/case.lux b/stdlib/source/lux/tool/compiler/phase/generation/js/case.lux
index 4561e5e84..86c7197ec 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/js/case.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/js/case.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux (#- case let if)
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["ex" exception (#+ exception:)]]
    [data
     ["." text
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js/extension/common.lux b/stdlib/source/lux/tool/compiler/phase/generation/js/extension/common.lux
index 2ee78f394..3cc75105f 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/js/extension/common.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/js/extension/common.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." monad (#+ do)]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js/extension/host.lux b/stdlib/source/lux/tool/compiler/phase/generation/js/extension/host.lux
index 70f581d69..f78daf215 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/js/extension/host.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/js/extension/host.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." monad (#+ do)]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js/function.lux b/stdlib/source/lux/tool/compiler/phase/generation/js/function.lux
index 10a53986f..4839c9978 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/js/function.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/js/function.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux (#- function)
+   [abstract
+    ["." monad (#+ do)]]
    [control
-    ["." monad (#+ do)]
     pipe]
    [data
     ["." product]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js/loop.lux b/stdlib/source/lux/tool/compiler/phase/generation/js/loop.lux
index d905db9a2..9ab04cae6 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/js/loop.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/js/loop.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux (#- Scope)
-   [control
+   [abstract
     ["." monad (#+ do)]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js/runtime.lux b/stdlib/source/lux/tool/compiler/phase/generation/js/runtime.lux
index 821633e50..97eee0025 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/js/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/js/runtime.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux #*
    ["." function]
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["p" parser]]
    [data
     [number (#+ hex)
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/js/structure.lux b/stdlib/source/lux/tool/compiler/phase/generation/js/structure.lux
index c6b413afb..a70376569 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/js/structure.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/js/structure.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." monad (#+ do)]]
    [host
     ["_" js (#+ Expression)]]]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python.lux b/stdlib/source/lux/tool/compiler/phase/generation/python.lux
index 29c95ff43..37a8d1bc6 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/python.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/python.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monad (#+ do)]]]
   [/
    [runtime (#+ Phase)]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/case.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/case.lux
index b1f53a8b2..359cfdb3b 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/python/case.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/python/case.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux (#- case let if)
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["ex" exception (#+ exception:)]]
    [data
     ["." text
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/extension/common.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/extension/common.lux
index 7ff70b393..46cd6d79e 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/python/extension/common.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/python/extension/common.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    ["." function]
-   [control
+   [abstract
     ["." monad (#+ do)]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/extension/host.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/extension/host.lux
index 92887899b..242022c87 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/python/extension/host.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/python/extension/host.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." monad (#+ do)]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/function.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/function.lux
index 3ba95e0f3..a5f918dc1 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/python/function.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/python/function.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux (#- function)
+   [abstract
+    ["." monad (#+ do)]]
    [control
-    ["." monad (#+ do)]
     pipe]
    [data
     ["." product]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/loop.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/loop.lux
index 7666319bf..12d83b756 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/python/loop.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/python/loop.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux (#- Scope)
-   [control
+   [abstract
     ["." monad (#+ do)]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/runtime.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/runtime.lux
index 36184e21c..d10434000 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/python/runtime.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/python/runtime.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux (#- inc)
    ["." function]
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["p" parser]]
    [data
     [number (#+ hex)
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/python/structure.lux b/stdlib/source/lux/tool/compiler/phase/generation/python/structure.lux
index 6daf5e532..93a83883d 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/python/structure.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/python/structure.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." monad (#+ do)]]
    [host
     ["_" python (#+ Expression)]]]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/scheme.lux b/stdlib/source/lux/tool/compiler/phase/generation/scheme.lux
index 5da2a016e..2ccf4f45a 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/scheme.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/scheme.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [monad (#+ do)]]]
   [/
    [runtime (#+ Phase)]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/scheme/case.jvm.lux b/stdlib/source/lux/tool/compiler/phase/generation/scheme/case.jvm.lux
index 49733e6f3..d68abbdd7 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/scheme/case.jvm.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/scheme/case.jvm.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux (#- case let if)
+   [abstract
+    [monad (#+ do)]]
    [control
-    [monad (#+ do)]
     ["ex" exception (#+ exception:)]]
    [data
     ["." number]
@@ -97,9 +98,9 @@
 (def: (pm-catch handler)
   (-> Expression Computation)
   (_.lambda [(list @alt-error) #.None]
-       (_.if (|> @alt-error (_.eqv?/2 pm-error))
-         handler
-         (_.raise/1 @alt-error))))
+            (_.if (|> @alt-error (_.eqv?/2 pm-error))
+              handler
+              (_.raise/1 @alt-error))))
 
 (def: (pattern-matching' generate pathP)
   (-> Phase Path (Operation Expression))
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/scheme/extension/common.jvm.lux b/stdlib/source/lux/tool/compiler/phase/generation/scheme/extension/common.jvm.lux
index 0de327e23..cb96a5718 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/scheme/extension/common.jvm.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/scheme/extension/common.jvm.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    ["." monad (#+ do)]]
    [control
-    ["." monad (#+ do)]
     ["ex" exception (#+ exception:)]]
    [data
     ["e" error]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/scheme/function.jvm.lux b/stdlib/source/lux/tool/compiler/phase/generation/scheme/function.jvm.lux
index 2cbb89825..28bfd36ba 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/scheme/function.jvm.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/scheme/function.jvm.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux (#- function)
+   [abstract
+    ["." monad (#+ do)]]
    [control
-    ["." monad (#+ do)]
     pipe]
    [data
     ["." product]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/scheme/loop.jvm.lux b/stdlib/source/lux/tool/compiler/phase/generation/scheme/loop.jvm.lux
index 7064c8301..6922806e2 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/scheme/loop.jvm.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/scheme/loop.jvm.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux (#- Scope)
-   [control
+   [abstract
     ["." monad (#+ do)]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/scheme/runtime.jvm.lux b/stdlib/source/lux/tool/compiler/phase/generation/scheme/runtime.jvm.lux
index d3c949df1..1e891c006 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/scheme/runtime.jvm.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/scheme/runtime.jvm.lux
@@ -1,9 +1,10 @@
 (.module:
   [lux #*
    ["." function]
-   [control
-    ["p" parser ("#;." monad)]
+   [abstract
     [monad (#+ do)]]
+   [control
+    ["p" parser ("#;." monad)]]
    [data
     [number (#+ hex)]
     [text
diff --git a/stdlib/source/lux/tool/compiler/phase/generation/scheme/structure.jvm.lux b/stdlib/source/lux/tool/compiler/phase/generation/scheme/structure.jvm.lux
index 7419ad239..e44ab508b 100644
--- a/stdlib/source/lux/tool/compiler/phase/generation/scheme/structure.jvm.lux
+++ b/stdlib/source/lux/tool/compiler/phase/generation/scheme/structure.jvm.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." monad (#+ do)]]
    [host
     ["_" scheme (#+ Expression)]]]
diff --git a/stdlib/source/lux/tool/compiler/phase/synthesis/case.lux b/stdlib/source/lux/tool/compiler/phase/synthesis/case.lux
index 7da1a41c7..ea8615949 100644
--- a/stdlib/source/lux/tool/compiler/phase/synthesis/case.lux
+++ b/stdlib/source/lux/tool/compiler/phase/synthesis/case.lux
@@ -1,9 +1,10 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
-    [pipe (#+ when> new> case>)]
     ["." monad (#+ do)]]
+   [control
+    [pipe (#+ when> new> case>)]]
    [data
     ["." product]
     ["." bit ("#@." equivalence)]
diff --git a/stdlib/source/lux/tool/compiler/phase/synthesis/function.lux b/stdlib/source/lux/tool/compiler/phase/synthesis/function.lux
index a1bc743c3..8d1b71d90 100644
--- a/stdlib/source/lux/tool/compiler/phase/synthesis/function.lux
+++ b/stdlib/source/lux/tool/compiler/phase/synthesis/function.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    ["." monad (#+ do)]]
    [control
-    ["." monad (#+ do)]
     ["ex" exception (#+ exception:)]]
    [data
     ["." maybe]
diff --git a/stdlib/source/lux/tool/compiler/phase/synthesis/loop.lux b/stdlib/source/lux/tool/compiler/phase/synthesis/loop.lux
index 54bec7b03..0ac6cc12b 100644
--- a/stdlib/source/lux/tool/compiler/phase/synthesis/loop.lux
+++ b/stdlib/source/lux/tool/compiler/phase/synthesis/loop.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux (#- loop)
+   [abstract
+    ["." monad (#+ do)]]
    [control
-    ["." monad (#+ do)]
     ["p" parser]]
    [data
     ["." maybe ("#;." monad)]
diff --git a/stdlib/source/lux/tool/compiler/reference.lux b/stdlib/source/lux/tool/compiler/reference.lux
index 7022b2496..20d819ef7 100644
--- a/stdlib/source/lux/tool/compiler/reference.lux
+++ b/stdlib/source/lux/tool/compiler/reference.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
-    [hash (#+ Hash)]
+    [hash (#+ Hash)]]
+   [control
     pipe]
    [data
     [text
diff --git a/stdlib/source/lux/tool/compiler/synthesis.lux b/stdlib/source/lux/tool/compiler/synthesis.lux
index 39b62ac88..d12c8c3ea 100644
--- a/stdlib/source/lux/tool/compiler/synthesis.lux
+++ b/stdlib/source/lux/tool/compiler/synthesis.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux (#- i64 Scope)
-   [control
+   [abstract
     [monad (#+ do)]
-    [equivalence (#+ Equivalence)]
+    [equivalence (#+ Equivalence)]]
+   [control
     ["ex" exception (#+ exception:)]]
    [data
     ["." bit ("#;." equivalence)]
diff --git a/stdlib/source/lux/type.lux b/stdlib/source/lux/type.lux
index 217b22abc..031e5025d 100644
--- a/stdlib/source/lux/type.lux
+++ b/stdlib/source/lux/type.lux
@@ -1,8 +1,9 @@
 (.module: {#.doc "Basic functionality for working with types."}
   [lux (#- function)
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
-    [monad (#+ Monad do)]
+    [monad (#+ Monad do)]]
+   [control
     ["p" parser]]
    [data
     ["." text ("#;." monoid equivalence)]
diff --git a/stdlib/source/lux/type/abstract.lux b/stdlib/source/lux/type/abstract.lux
index 1a45c6e56..d293c4083 100644
--- a/stdlib/source/lux/type/abstract.lux
+++ b/stdlib/source/lux/type/abstract.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux (#- Scope)
+   [abstract
+    [monad (#+ Monad do)]]
    [control
-    [monad (#+ Monad do)]
     ["p" parser ("#;." monad)]
     ["ex" exception (#+ exception:)]]
    [data
diff --git a/stdlib/source/lux/type/check.lux b/stdlib/source/lux/type/check.lux
index 636a1722e..359a0e3b0 100644
--- a/stdlib/source/lux/type/check.lux
+++ b/stdlib/source/lux/type/check.lux
@@ -1,9 +1,10 @@
 (.module: {#.doc "Type-checking functionality."}
   [lux #*
-   [control
+   [abstract
     [functor (#+ Functor)]
     [apply (#+ Apply)]
-    ["." monad (#+ Monad do)]
+    ["." monad (#+ Monad do)]]
+   [control
     ["ex" exception (#+ exception:)]]
    [data
     ["." maybe]
diff --git a/stdlib/source/lux/type/implicit.lux b/stdlib/source/lux/type/implicit.lux
index 36d9b2e03..d8ce47c2c 100644
--- a/stdlib/source/lux/type/implicit.lux
+++ b/stdlib/source/lux/type/implicit.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux #*
-   [control
+   [abstract
     ["." monad (#+ do Monad)]
-    ["eq" equivalence]
+    ["eq" equivalence]]
+   [control
     ["p" parser]]
    [data
     ["." product]
diff --git a/stdlib/source/lux/type/refinement.lux b/stdlib/source/lux/type/refinement.lux
index 2444878b4..1c428fc23 100644
--- a/stdlib/source/lux/type/refinement.lux
+++ b/stdlib/source/lux/type/refinement.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux (#- type)
-   [control
+   [abstract
     [predicate (#+ Predicate)]]
    [type (#+ :by-example) ("#;." equivalence)
     abstract]])
diff --git a/stdlib/source/lux/type/resource.lux b/stdlib/source/lux/type/resource.lux
index affcf4cfc..22d83defd 100644
--- a/stdlib/source/lux/type/resource.lux
+++ b/stdlib/source/lux/type/resource.lux
@@ -1,10 +1,11 @@
 (.module:
   [lux #*
+   [abstract
+    ["." monad (#+ Monad do)
+     [indexed (#+ IxMonad)]]]
    [control
     ["p" parser]
     ["ex" exception (#+ exception:)]
-    ["." monad (#+ Monad do)
-     [indexed (#+ IxMonad)]]
     [concurrency
      ["." promise (#+ Promise)]]]
    [data
diff --git a/stdlib/source/lux/type/unit.lux b/stdlib/source/lux/type/unit.lux
index d28f3e841..a05b7c85c 100644
--- a/stdlib/source/lux/type/unit.lux
+++ b/stdlib/source/lux/type/unit.lux
@@ -1,12 +1,13 @@
 ## TODO: Write tests ASAP.
 (.module:
   [lux #*
-   [control
+   [abstract
     [monad (#+ Monad do)]
-    ["p" parser]
     [equivalence (#+ Equivalence)]
     [order (#+ Order)]
     [enum (#+ Enum)]]
+   [control
+    ["p" parser]]
    [data
     [number
      ["r" ratio]]
diff --git a/stdlib/source/lux/world/binary.lux b/stdlib/source/lux/world/binary.lux
index e373937b9..f43edfa4f 100644
--- a/stdlib/source/lux/world/binary.lux
+++ b/stdlib/source/lux/world/binary.lux
@@ -1,9 +1,10 @@
 (.module:
   [lux (#- i64)
-   [control
+   [abstract
     [monad (#+ do)]
-    ["ex" exception (#+ exception:)]
     [equivalence (#+ Equivalence)]]
+   [control
+    ["ex" exception (#+ exception:)]]
    [data
     ["." maybe]
     ["." error (#+ Error)]
diff --git a/stdlib/source/lux/world/file.lux b/stdlib/source/lux/world/file.lux
index 1ee35cd6f..c559c83e6 100644
--- a/stdlib/source/lux/world/file.lux
+++ b/stdlib/source/lux/world/file.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    ["." monad (#+ Monad do)]]
    [control
-    ["." monad (#+ Monad do)]
     ["ex" exception (#+ Exception exception:)]
     [concurrency
      ["." promise (#+ Promise)]]
diff --git a/stdlib/source/lux/world/net/tcp.jvm.lux b/stdlib/source/lux/world/net/tcp.jvm.lux
index d72e24763..f9c72bff3 100644
--- a/stdlib/source/lux/world/net/tcp.jvm.lux
+++ b/stdlib/source/lux/world/net/tcp.jvm.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    monad]
    [control
-    monad
     [concurrency
      ["." promise (#+ Promise Resolver)]
      ["." frp (#+ Channel Sink)]]
diff --git a/stdlib/source/lux/world/net/udp.jvm.lux b/stdlib/source/lux/world/net/udp.jvm.lux
index 01eb4772a..505871b56 100644
--- a/stdlib/source/lux/world/net/udp.jvm.lux
+++ b/stdlib/source/lux/world/net/udp.jvm.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    monad]
    [control
-    monad
     ["ex" exception (#+ exception:)]
     [concurrency
      ["." promise (#+ Promise)]]
diff --git a/stdlib/source/program/licentia.lux b/stdlib/source/program/licentia.lux
index 87ec7a9eb..482777503 100644
--- a/stdlib/source/program/licentia.lux
+++ b/stdlib/source/program/licentia.lux
@@ -13,9 +13,10 @@
 
 (.module:
   [lux #*
+   [abstract
+    [monad (#+ do)]]
    [control
     [remember (#+ to-do)]
-    [monad (#+ do)]
     ["." parser]
     [security
      ["!" capability]]]
diff --git a/stdlib/source/program/scriptum.lux b/stdlib/source/program/scriptum.lux
index 23b1d575b..37205402e 100644
--- a/stdlib/source/program/scriptum.lux
+++ b/stdlib/source/program/scriptum.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux #*
+   [abstract
+    ["." monad (#+ do)]]
    [control
     [pipe (#+ when>)]
-    ["." monad (#+ do)]
     ["ex" exception (#+ exception:)]
     [security
      ["!" capability]]]
diff --git a/stdlib/source/test/licentia.lux b/stdlib/source/test/licentia.lux
index 1526b8a04..7f623d26d 100644
--- a/stdlib/source/test/licentia.lux
+++ b/stdlib/source/test/licentia.lux
@@ -2,9 +2,8 @@
   [lux #*
    [cli (#+ program:)]
    ["_" test (#+ Test)]
+   [abstract/monad (#+ do)]
    [io (#+ io)]
-   [control
-    [monad (#+ do)]]
    [data
     ["." bit ("#;." equivalence)]
     ["." maybe ("#;." functor)]
diff --git a/stdlib/source/test/lux.lux b/stdlib/source/test/lux.lux
index 4caf29c32..5b45d6e5e 100644
--- a/stdlib/source/test/lux.lux
+++ b/stdlib/source/test/lux.lux
@@ -12,7 +12,7 @@
     ["/" lux #*
      [cli (#+ program:)]
      ["." io (#+ io)]
-     [control
+     [abstract
       [monad (#+ do)]
       [predicate (#+ Predicate)]]
      [data
@@ -112,6 +112,7 @@
     ["." / #_
      ["#." cli]
      ["#." io]
+     ["#." abstract]
      ["#." control]
      ["#." data]
      ["#." macro]
@@ -354,6 +355,8 @@
               ..cross-platform-support)
           /cli.test
           /io.test
+          (<| (_.context "/abstract")
+              /abstract.test)
           (<| (_.context "/control")
               /control.test)
           (<| (_.context "/data")
diff --git a/stdlib/source/test/lux/abstract.lux b/stdlib/source/test/lux/abstract.lux
new file mode 100644
index 000000000..4d37ed458
--- /dev/null
+++ b/stdlib/source/test/lux/abstract.lux
@@ -0,0 +1,11 @@
+(.module:
+  [lux #*
+   ["_" test (#+ Test)]]
+  ["." / #_
+   ["#." interval]])
+
+(def: #export test
+  Test
+  ($_ _.and
+      /interval.test
+      ))
diff --git a/stdlib/source/test/lux/abstract/apply.lux b/stdlib/source/test/lux/abstract/apply.lux
new file mode 100644
index 000000000..a269810bb
--- /dev/null
+++ b/stdlib/source/test/lux/abstract/apply.lux
@@ -0,0 +1,71 @@
+(.module:
+  [lux #*
+   [abstract/monad (#+ do)]
+   [data
+    [text
+     format]]
+   ["." function]
+   [math
+    ["r" random]]
+   ["_" test (#+ Test)]]
+  {1
+   ["." / (#+ Apply)]}
+  [//
+   [functor (#+ Injection Comparison)]])
+
+(def: (identity injection comparison (^open "_;."))
+  (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
+  (do r.monad
+    [sample (:: @ map injection r.nat)]
+    (_.test "Identity."
+            ((comparison n/=)
+             (_;apply (injection function.identity) sample)
+             sample))))
+
+(def: (homomorphism injection comparison (^open "_;."))
+  (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
+  (do r.monad
+    [sample r.nat
+     increase (:: @ map n/+ r.nat)]
+    (_.test "Homomorphism."
+            ((comparison n/=)
+             (_;apply (injection increase) (injection sample))
+             (injection (increase sample))))))
+
+(def: (interchange injection comparison (^open "_;."))
+  (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
+  (do r.monad
+    [sample r.nat
+     increase (:: @ map n/+ r.nat)]
+    (_.test "Interchange."
+            ((comparison n/=)
+             (_;apply (injection increase) (injection sample))
+             (_;apply (injection (function (_ f) (f sample))) (injection increase))))))
+
+(def: (composition injection comparison (^open "_;."))
+  (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
+  (do r.monad
+    [sample r.nat
+     increase (:: @ map n/+ r.nat)
+     decrease (:: @ map n/- r.nat)]
+    (_.test "Composition."
+            ((comparison n/=)
+             (_$ _;apply
+                 (injection function.compose)
+                 (injection increase)
+                 (injection decrease)
+                 (injection sample))
+             ($_ _;apply
+                 (injection increase)
+                 (injection decrease)
+                 (injection sample))))))
+
+(def: #export (spec injection comparison apply)
+  (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
+  (_.context (%name (name-of /.Apply))
+             ($_ _.and
+                 (..identity injection comparison apply)
+                 (..homomorphism injection comparison apply)
+                 (..interchange injection comparison apply)
+                 (..composition injection comparison apply)
+                 )))
diff --git a/stdlib/source/test/lux/abstract/codec.lux b/stdlib/source/test/lux/abstract/codec.lux
new file mode 100644
index 000000000..80203c237
--- /dev/null
+++ b/stdlib/source/test/lux/abstract/codec.lux
@@ -0,0 +1,26 @@
+(.module:
+  [lux #*
+   ["_" test (#+ Test)]
+   [abstract/monad (#+ do)]
+   [data
+    text/format
+    ["." error]]
+   [math
+    ["r" random (#+ Random)]]]
+  {1
+   ["." / (#+ Codec)
+    [//
+     [equivalence (#+ Equivalence)]]]})
+
+(def: #export (spec (^open "/@.") (^open "/@.") generator)
+  (All [m a] (-> (Equivalence a) (Codec m a) (Random a) Test))
+  (do r.monad
+    [expected generator]
+    (<| (_.context (%name (name-of /.Codec)))
+        (_.test "Isomorphism."
+                (case (|> expected /@encode /@decode)
+                  (#error.Success actual)
+                  (/@= expected actual)
+                  
+                  (#error.Failure error)
+                  false)))))
diff --git a/stdlib/source/test/lux/abstract/enum.lux b/stdlib/source/test/lux/abstract/enum.lux
new file mode 100644
index 000000000..63bbf97ad
--- /dev/null
+++ b/stdlib/source/test/lux/abstract/enum.lux
@@ -0,0 +1,27 @@
+(.module:
+  [lux #*
+   data/text/format
+   ["_" test (#+ Test)]
+   ["." function]
+   [abstract/monad (#+ do)]
+   [math
+    ["r" random (#+ Random)]]]
+  {1
+   ["." / (#+ Enum)]})
+
+(def: #export (spec (^open "/@.") gen-sample)
+  (All [a] (-> (Enum a) (Random a) Test))
+  (do r.monad
+    [sample gen-sample]
+    (<| (_.context (%name (name-of /.Order)))
+        ($_ _.and
+            (_.test "Successor and predecessor are inverse functions."
+                    (and (/@= (|> sample /@succ /@pred)
+                              (function.identity sample))
+                         (/@= (|> sample /@pred /@succ)
+                              (function.identity sample))
+                         (not (/@= (|> sample /@succ)
+                                   (function.identity sample)))
+                         (not (/@= (|> sample /@pred)
+                                   (function.identity sample)))))
+            ))))
diff --git a/stdlib/source/test/lux/abstract/equivalence.lux b/stdlib/source/test/lux/abstract/equivalence.lux
new file mode 100644
index 000000000..d9e61131f
--- /dev/null
+++ b/stdlib/source/test/lux/abstract/equivalence.lux
@@ -0,0 +1,25 @@
+(.module:
+  [lux #*
+   ["_" test (#+ Test)]
+   [abstract/monad (#+ do)]
+   [data
+    [text
+     format]]
+   [math
+    ["r" random (#+ Random)]]]
+  {1
+   ["." / (#+ Equivalence)]})
+
+(def: #export (spec (^open "_@.") generator)
+  (All [a] (-> (Equivalence a) (Random a) Test))
+  (do r.monad
+    [left generator
+     right generator]
+    (<| (_.context (%name (name-of /.Equivalence)))
+        ($_ _.and
+            (_.test "Reflexivity."
+                    (_@= left left))
+            (_.test "Symmetry."
+                    (if (_@= left right)
+                      (_@= right left)
+                      (not (_@= right left))))))))
diff --git a/stdlib/source/test/lux/abstract/fold.lux b/stdlib/source/test/lux/abstract/fold.lux
new file mode 100644
index 000000000..8dfe7fc4c
--- /dev/null
+++ b/stdlib/source/test/lux/abstract/fold.lux
@@ -0,0 +1,20 @@
+(.module:
+  [lux #*
+   ["_" test (#+ Test)]
+   data/text/format
+   ["r" math/random]
+   [abstract/monad (#+ do)]]
+  [//
+   [functor (#+ Injection Comparison)]]
+  {1
+   ["." / (#+ Fold)]})
+
+(def: #export (spec injection comparison (^open "/@."))
+  (All [f] (-> (Injection f) (Comparison f) (Fold f) Test))
+  (_.context (%name (name-of /.Fold))
+             (do r.monad
+               [subject r.nat
+                parameter r.nat]
+               (_.test "Can fold."
+                       (n/= (/@fold n/+ parameter (injection subject))
+                            (n/+ parameter subject))))))
diff --git a/stdlib/source/test/lux/abstract/functor.lux b/stdlib/source/test/lux/abstract/functor.lux
new file mode 100644
index 000000000..cf3538575
--- /dev/null
+++ b/stdlib/source/test/lux/abstract/functor.lux
@@ -0,0 +1,58 @@
+(.module:
+  [lux #*
+   ["_" test (#+ Test)]
+   data/text/format
+   ["r" math/random]
+   [abstract
+    [equivalence (#+ Equivalence)]
+    [monad (#+ do)]]
+   ["." function]]
+  {1
+   ["." / (#+ Functor)]})
+
+(type: #export (Injection f)
+  (All [a] (-> a (f a))))
+
+(type: #export (Comparison f)
+  (All [a]
+    (-> (Equivalence a)
+        (Equivalence (f a)))))
+
+(def: (identity injection comparison (^open "/@."))
+  (All [f] (-> (Injection f) (Comparison f) (Functor f) Test))
+  (do r.monad
+    [sample (:: @ map injection r.nat)]
+    (_.test "Identity."
+            ((comparison n/=)
+             (/@map function.identity sample)
+             sample))))
+
+(def: (homomorphism injection comparison (^open "/@."))
+  (All [f] (-> (Injection f) (Comparison f) (Functor f) Test))
+  (do r.monad
+    [sample r.nat
+     increase (:: @ map n/+ r.nat)]
+    (_.test "Homomorphism."
+            ((comparison n/=)
+             (/@map increase (injection sample))
+             (injection (increase sample))))))
+
+(def: (composition injection comparison (^open "/@."))
+  (All [f] (-> (Injection f) (Comparison f) (Functor f) Test))
+  (do r.monad
+    [sample (:: @ map injection r.nat)
+     increase (:: @ map n/+ r.nat)
+     decrease (:: @ map n/- r.nat)]
+    (_.test "Composition."
+            ((comparison n/=)
+             (|> sample (/@map increase) (/@map decrease))
+             (|> sample (/@map (|>> increase decrease)))))))
+
+(def: #export (spec injection comparison functor)
+  (All [f] (-> (Injection f) (Comparison f) (Functor f) Test))
+  (_.context (%name (name-of /.Functor))
+             ($_ _.and
+                 (..identity injection comparison functor)
+                 (..homomorphism injection comparison functor)
+                 (..composition injection comparison functor)
+                 )))
diff --git a/stdlib/source/test/lux/abstract/interval.lux b/stdlib/source/test/lux/abstract/interval.lux
new file mode 100644
index 000000000..cfc19f6a9
--- /dev/null
+++ b/stdlib/source/test/lux/abstract/interval.lux
@@ -0,0 +1,248 @@
+(.module:
+  [lux #*
+   ["_" test (#+ Test)]
+   [abstract/monad (#+ do)]
+   [abstract
+    {[0 #test]
+     [/
+      ["$." equivalence]]}]
+   [control
+    [pipe (#+ case>)]]
+   [data
+    [number
+     ["." nat]]
+    [text
+     format]
+    [collection
+     ["." set]
+     ["." list]]]
+   [math
+    ["r" random (#+ Random)]]]
+  {1
+   ["." / (#+ Interval) ("_@." equivalence)]})
+
+(template [<name> <cmp>]
+  [(def: #export <name>
+     (Random (Interval Nat))
+     (do r.monad
+       [bottom r.nat
+        top (|> r.nat (r.filter (|>> (n/= bottom) not)))]
+       (if (<cmp> top bottom)
+         (wrap (/.between nat.enum bottom top))
+         (wrap (/.between nat.enum top bottom)))))]
+
+  [inner n/<]
+  [outer n/>]
+  )
+
+(def: #export singleton
+  (Random (Interval Nat))
+  (do r.monad
+    [point r.nat]
+    (wrap (/.singleton nat.enum point))))
+
+(def: #export interval
+  (Random (Interval Nat))
+  ($_ r.either
+      ..inner
+      ..outer
+      ..singleton))
+
+(def: boundaries
+  Test
+  (do r.monad
+    [bottom r.nat
+     top r.nat
+     #let [interval (/.between nat.enum bottom top)]]
+    ($_ _.and
+        (_.test "A boundary value belongs to its interval."
+                (and (/.within? interval bottom)
+                     (/.within? interval top)))
+        (_.test "An interval starts with its bottom."
+                (/.starts-with? bottom interval))
+        (_.test "An interval ends with its top."
+                (/.ends-with? top interval))
+        (_.test "The boundary values border the interval."
+                (and (/.borders? interval bottom)
+                     (/.borders? interval top)))
+        )))
+
+(def: union
+  Test
+  (do r.monad
+    [some-interval ..interval
+     left-inner ..inner
+     right-inner ..inner
+     left-singleton ..singleton
+     right-singleton ..singleton
+     left-outer ..outer
+     right-outer ..outer]
+    ($_ _.and
+        (_.test "The union of an interval to itself yields the same interval."
+                (_@= some-interval (/.union some-interval some-interval)))
+        (_.test "The union of 2 inner intervals is another inner interval."
+                (/.inner? (/.union left-inner right-inner)))
+        (_.test "The union of 2 outer intervals yields an inner interval when their complements don't overlap, and an outer when they do."
+                (if (/.overlaps? (/.complement left-outer) (/.complement right-outer))
+                  (/.outer? (/.union left-outer right-outer))
+                  (/.inner? (/.union left-outer right-outer))))
+        )))
+
+(def: intersection
+  Test
+  (do r.monad
+    [some-interval ..interval
+     left-inner ..inner
+     right-inner ..inner
+     left-singleton ..singleton
+     right-singleton ..singleton
+     left-outer ..outer
+     right-outer ..outer]
+    ($_ _.and
+        (_.test "The intersection of an interval to itself yields the same interval."
+                (_@= some-interval (/.intersection some-interval some-interval)))
+        (_.test "The intersection of 2 inner intervals yields an inner interval when they overlap, and an outer when they don't."
+                (if (/.overlaps? left-inner right-inner)
+                  (/.inner? (/.intersection left-inner right-inner))
+                  (/.outer? (/.intersection left-inner right-inner))))
+        (_.test "The intersection of 2 outer intervals is another outer interval."
+                (/.outer? (/.intersection left-outer right-outer)))
+        )))
+
+(def: complement
+  Test
+  (do r.monad
+    [some-interval ..interval]
+    ($_ _.and
+        (_.test "The complement of a complement is the same as the original."
+                (_@= some-interval (|> some-interval /.complement /.complement)))
+        (_.test "The complement of an interval does not overlap it."
+                (not (/.overlaps? some-interval (/.complement some-interval))))
+        )))
+
+(def: location
+  Test
+  (do r.monad
+    [[l m r] (|> (r.set nat.hash 3 r.nat)
+                 (:: @ map (|>> set.to-list
+                                (list.sort n/<)
+                                (case> (^ (list b t1 t2))
+                                       [b t1 t2]
+
+                                       _
+                                       (undefined)))))
+     #let [left (/.singleton nat.enum l)
+           right (/.singleton nat.enum r)]]
+    ($_ _.and
+        (_.test "'precedes?' and 'succeeds?' are symetric."
+                (and (/.precedes? right left)
+                     (/.succeeds? left right)))
+        (_.test "Can check if an interval is before or after some element."
+                (and (/.before? m left)
+                     (/.after? m right)))
+        )))
+
+(def: touch
+  Test
+  (do r.monad
+    [[b t1 t2] (|> (r.set nat.hash 3 r.nat)
+                   (:: @ map (|>> set.to-list
+                                  (list.sort n/<)
+                                  (case> (^ (list b t1 t2))
+                                         [b t1 t2]
+
+                                         _
+                                         (undefined)))))
+     #let [int-left (/.between nat.enum t1 t2)
+           int-right (/.between nat.enum b t1)]]
+    ($_ _.and
+        (_.test "An interval meets another if its top is the other's bottom."
+                (/.meets? int-left int-right))
+        (_.test "Two intervals touch one another if any one meets the other."
+                (/.touches? int-left int-right))
+        (_.test "Can check if 2 intervals start together."
+                (/.starts? (/.between nat.enum b t2)
+                           (/.between nat.enum b t1)))
+        (_.test "Can check if 2 intervals finish together."
+                (/.finishes? (/.between nat.enum b t2)
+                             (/.between nat.enum t1 t2)))
+        )))
+
+(def: overlap
+  Test
+  (do r.monad
+    [some-interval ..interval
+     [x0 x1 x2 x3] (|> (r.set nat.hash 4 r.nat)
+                       (:: @ map (|>> set.to-list
+                                      (list.sort n/<)
+                                      (case> (^ (list x0 x1 x2 x3))
+                                             [x0 x1 x2 x3]
+
+                                             _
+                                             (undefined)))))]
+    ($_ _.and
+        (_.test "Every interval is nested into itself."
+                (/.nested? some-interval some-interval))
+        (_.test "No interval overlaps with itself."
+                (not (/.overlaps? some-interval some-interval)))
+        (let [small-inner (/.between nat.enum x1 x2)
+              large-inner (/.between nat.enum x0 x3)]
+          (_.test "Inner intervals can be nested inside one another."
+                  (and (/.nested? large-inner small-inner)
+                       (not (/.nested? small-inner large-inner)))))
+        (let [left-inner (/.between nat.enum x0 x2)
+              right-inner (/.between nat.enum x1 x3)]
+          (_.test "Inner intervals can overlap one another."
+                  (and (/.overlaps? left-inner right-inner)
+                       (/.overlaps? right-inner left-inner))))
+        (let [small-outer (/.between nat.enum x2 x1)
+              large-outer (/.between nat.enum x3 x0)]
+          (_.test "Outer intervals can be nested inside one another."
+                  (and (/.nested? small-outer large-outer)
+                       (not (/.nested? large-outer small-outer)))))
+        (let [left-inner (/.between nat.enum x0 x1)
+              right-inner (/.between nat.enum x2 x3)
+              outer (/.between nat.enum x0 x3)]
+          (_.test "Inners can be nested inside outers."
+                  (and (/.nested? outer left-inner)
+                       (/.nested? outer right-inner))))
+        (let [left-inner (/.between nat.enum x0 x2)
+              right-inner (/.between nat.enum x1 x3)
+              outer (/.between nat.enum x1 x2)]
+          (_.test "Inners can overlap outers."
+                  (and (/.overlaps? outer left-inner)
+                       (/.overlaps? outer right-inner))))
+        )))
+
+(def: #export test
+  Test
+  (<| (_.context (%name (name-of /.Interval)))
+      ($_ _.and
+          ($equivalence.spec /.equivalence ..interval)
+          (<| (_.context "Boundaries.")
+              ..boundaries)
+          (<| (_.context "Union.")
+              ..union)
+          (<| (_.context "Intersection.")
+              ..intersection)
+          (<| (_.context "Complement.")
+              ..complement)
+          (<| (_.context "Positioning/location.")
+              ..location)
+          (<| (_.context "Touching intervals.")
+              ..touch)
+          (<| (_.context "Nesting & overlap.")
+              ..overlap)
+          )))
+
+(def: #export (spec (^open "_@.") gen-sample)
+  (All [a] (-> (Interval a) (Random a) Test))
+  (<| (_.context (%name (name-of /.Interval)))
+      (do r.monad
+        [sample gen-sample]
+        ($_ _.and
+            (_.test "No value is bigger than the top."
+                    (_@< _@top sample))
+            (_.test "No value is smaller than the bottom."
+                    (_@> _@bottom sample))
+            ))))
diff --git a/stdlib/source/test/lux/abstract/monad.lux b/stdlib/source/test/lux/abstract/monad.lux
new file mode 100644
index 000000000..4382a260d
--- /dev/null
+++ b/stdlib/source/test/lux/abstract/monad.lux
@@ -0,0 +1,58 @@
+(.module:
+  [lux #*
+   [data
+    [text
+     format]]
+   ["." function]
+   [math
+    ["r" random]]
+   ["_" test (#+ Test)]]
+  {1
+   ["." / (#+ Monad do)]}
+  [//
+   [functor (#+ Injection Comparison)]])
+
+(def: (left-identity injection comparison (^open "_;."))
+  (All [f] (-> (Injection f) (Comparison f) (Monad f) Test))
+  (do r.monad
+    [sample r.nat
+     morphism (:: @ map (function (_ diff)
+                          (|>> (n/+ diff) _;wrap))
+                  r.nat)]
+    (_.test "Left identity."
+            ((comparison n/=)
+             (|> (injection sample) (_;map morphism) _;join)
+             (morphism sample)))))
+
+(def: (right-identity injection comparison (^open "_;."))
+  (All [f] (-> (Injection f) (Comparison f) (Monad f) Test))
+  (do r.monad
+    [sample r.nat]
+    (_.test "Right identity."
+            ((comparison n/=)
+             (|> (injection sample) (_;map _;wrap) _;join)
+             (injection sample)))))
+
+(def: (associativity injection comparison (^open "_;."))
+  (All [f] (-> (Injection f) (Comparison f) (Monad f) Test))
+  (do r.monad
+    [sample r.nat
+     increase (:: @ map (function (_ diff)
+                          (|>> (n/+ diff) _;wrap))
+                  r.nat)
+     decrease (:: @ map (function (_ diff)
+                          (|>> (n/- diff) _;wrap))
+                  r.nat)]
+    (_.test "Associativity."
+            ((comparison n/=)
+             (|> (injection sample) (_;map increase) _;join (_;map decrease) _;join)
+             (|> (injection sample) (_;map (|>> increase (_;map decrease) _;join)) _;join)))))
+
+(def: #export (spec injection comparison monad)
+  (All [f] (-> (Injection f) (Comparison f) (Monad f) Test))
+  (_.context (%name (name-of /.Monad))
+             ($_ _.and
+                 (..left-identity injection comparison monad)
+                 (..right-identity injection comparison monad)
+                 (..associativity injection comparison monad)
+                 )))
diff --git a/stdlib/source/test/lux/abstract/monoid.lux b/stdlib/source/test/lux/abstract/monoid.lux
new file mode 100644
index 000000000..b526c3e58
--- /dev/null
+++ b/stdlib/source/test/lux/abstract/monoid.lux
@@ -0,0 +1,24 @@
+(.module:
+  [lux #*
+   data/text/format
+   ["_" test (#+ Test)]
+   ["." function]
+   [abstract/monad (#+ do)]
+   [math
+    ["r" random (#+ Random)]]]
+  {1
+   ["." / (#+ Monoid)
+    [//
+     [equivalence (#+ Equivalence)]]]})
+
+(def: #export (spec (^open "/@.") (^open "/@.") gen-sample)
+  (All [a] (-> (Equivalence a) (Monoid a) (Random a) Test))
+  (do r.monad
+    [sample gen-sample]
+    (<| (_.context (%name (name-of /.Monoid)))
+        ($_ _.and
+            (_.test "Left identity."
+                    (/@= sample (/@compose /@identity sample)))
+            (_.test "Right identity."
+                    (/@= sample (/@compose sample /@identity)))
+            ))))
diff --git a/stdlib/source/test/lux/abstract/number.lux b/stdlib/source/test/lux/abstract/number.lux
new file mode 100644
index 000000000..2d726dfed
--- /dev/null
+++ b/stdlib/source/test/lux/abstract/number.lux
@@ -0,0 +1,46 @@
+(.module:
+  [lux #*
+   ["_" test (#+ Test)]
+   [abstract/monad (#+ do)]
+   [data
+    [text
+     format]]
+   [math
+    ["r" random (#+ Random)]]]
+  {1
+   ["." / (#+ Number)
+    [//
+     [order (#+ Order)]]]})
+
+(def: #export (spec (^open "/@.") (^open "/@.") gen-sample)
+  (All [a] (-> (Order a) (Number a) (Random a) Test))
+  (do r.monad
+    [#let [non-zero (r.filter (function (_ sample)
+                                (|> sample (/@+ sample) (/@= sample) not))
+                              gen-sample)]
+     parameter non-zero
+     subject non-zero]
+    (<| (_.context (%name (name-of /.Number)))
+        ($_ _.and
+            (_.test "Addition and subtraction are inverse functions."
+                    (|> subject (/@+ parameter) (/@- parameter) (/@= subject)))
+            (_.test "Multiplication and division are inverse functions."
+                    (|> subject (/@* parameter) (/@/ parameter) (/@= subject)))
+            (_.test "Modulus fills all the information division misses."
+                    (let [modulus (/@% parameter subject)
+                          multiple (/@- modulus subject)
+                          factor (/@/ parameter multiple)]
+                      (|> parameter (/@* factor) (/@+ modulus) (/@= subject))))
+            (_.test "Negation flips the sign of a number and mimics subtraction."
+                    (let [unsigned? (/@= (/@signum parameter)
+                                         (/@signum (/@negate parameter)))]
+                      (or unsigned?
+                          (/@= (/@+ (/@negate parameter) subject)
+                               (/@- parameter subject)))))
+            (_.test "The absolute value is always positive."
+                    (let [unsigned? (/@= parameter
+                                         (/@negate parameter))]
+                      (if unsigned?
+                        (/@= subject (/@abs subject))
+                        (/@>= subject (/@abs subject)))))
+            ))))
diff --git a/stdlib/source/test/lux/abstract/order.lux b/stdlib/source/test/lux/abstract/order.lux
new file mode 100644
index 000000000..535d774a7
--- /dev/null
+++ b/stdlib/source/test/lux/abstract/order.lux
@@ -0,0 +1,26 @@
+(.module:
+  [lux #*
+   ["_" test (#+ Test)]
+   [abstract/monad (#+ do)]
+   [data
+    [text
+     format]]
+   [math
+    ["r" random (#+ Random)]]]
+  {1
+   ["." / (#+ Order)]})
+
+(def: #export (spec (^open ",@.") generator)
+  (All [a] (-> (Order a) (Random a) Test))
+  (do r.monad
+    [left generator
+     right generator]
+    (<| (_.context (%name (name-of /.Order)))
+        ($_ _.and
+            (_.test "Values are either ordered, or they are equal. All options are mutually exclusive."
+                    (if (,@= left right)
+                      (not (or (,@< left right)
+                               (,@> left right)))
+                      (if (,@< left right)
+                        (not (,@> left right))
+                        (,@> left right))))))))
diff --git a/stdlib/source/test/lux/cli.lux b/stdlib/source/test/lux/cli.lux
index 361b447ee..ff7a3abb3 100644
--- a/stdlib/source/test/lux/cli.lux
+++ b/stdlib/source/test/lux/cli.lux
@@ -1,10 +1,10 @@
 (.module:
   [lux #*
    data/text/format
+   ["M" abstract/monad (#+ Monad do)]
    ["_" test (#+ Test)]
    ["r" math/random]
    [control
-    ["M" monad (#+ Monad do)]
     pipe
     ["p" parser]]
    [data
diff --git a/stdlib/source/test/lux/control.lux b/stdlib/source/test/lux/control.lux
index 912729c42..341a119fe 100644
--- a/stdlib/source/test/lux/control.lux
+++ b/stdlib/source/test/lux/control.lux
@@ -4,7 +4,6 @@
   ["." / #_
    ["#." continuation]
    ["#." exception]
-   ["#." interval]
    ["#." parser]
    ["#." pipe]
    ["#." reader]
@@ -44,7 +43,6 @@
   ($_ _.and
       /continuation.test
       /exception.test
-      /interval.test
       /parser.test
       (<| (_.context "/pipe")
           /pipe.test)
diff --git a/stdlib/source/test/lux/control/apply.lux b/stdlib/source/test/lux/control/apply.lux
deleted file mode 100644
index 881e5d127..000000000
--- a/stdlib/source/test/lux/control/apply.lux
+++ /dev/null
@@ -1,72 +0,0 @@
-(.module:
-  [lux #*
-   [control
-    [monad (#+ do)]]
-   [data
-    [text
-     format]]
-   ["." function]
-   [math
-    ["r" random]]
-   ["_" test (#+ Test)]]
-  {1
-   ["." / (#+ Apply)]}
-  [//
-   [functor (#+ Injection Comparison)]])
-
-(def: (identity injection comparison (^open "_;."))
-  (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
-  (do r.monad
-    [sample (:: @ map injection r.nat)]
-    (_.test "Identity."
-            ((comparison n/=)
-             (_;apply (injection function.identity) sample)
-             sample))))
-
-(def: (homomorphism injection comparison (^open "_;."))
-  (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
-  (do r.monad
-    [sample r.nat
-     increase (:: @ map n/+ r.nat)]
-    (_.test "Homomorphism."
-            ((comparison n/=)
-             (_;apply (injection increase) (injection sample))
-             (injection (increase sample))))))
-
-(def: (interchange injection comparison (^open "_;."))
-  (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
-  (do r.monad
-    [sample r.nat
-     increase (:: @ map n/+ r.nat)]
-    (_.test "Interchange."
-            ((comparison n/=)
-             (_;apply (injection increase) (injection sample))
-             (_;apply (injection (function (_ f) (f sample))) (injection increase))))))
-
-(def: (composition injection comparison (^open "_;."))
-  (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
-  (do r.monad
-    [sample r.nat
-     increase (:: @ map n/+ r.nat)
-     decrease (:: @ map n/- r.nat)]
-    (_.test "Composition."
-            ((comparison n/=)
-             (_$ _;apply
-                 (injection function.compose)
-                 (injection increase)
-                 (injection decrease)
-                 (injection sample))
-             ($_ _;apply
-                 (injection increase)
-                 (injection decrease)
-                 (injection sample))))))
-
-(def: #export (spec injection comparison apply)
-  (All [f] (-> (Injection f) (Comparison f) (Apply f) Test))
-  (_.context (%name (name-of /.Apply))
-             ($_ _.and
-                 (..identity injection comparison apply)
-                 (..homomorphism injection comparison apply)
-                 (..interchange injection comparison apply)
-                 (..composition injection comparison apply)
-                 )))
diff --git a/stdlib/source/test/lux/control/codec.lux b/stdlib/source/test/lux/control/codec.lux
deleted file mode 100644
index f8159838b..000000000
--- a/stdlib/source/test/lux/control/codec.lux
+++ /dev/null
@@ -1,27 +0,0 @@
-(.module:
-  [lux #*
-   ["_" test (#+ Test)]
-   [control
-    [monad (#+ do)]]
-   [data
-    text/format
-    ["." error]]
-   [math
-    ["r" random (#+ Random)]]]
-  {1
-   ["." / (#+ Codec)
-    [//
-     [equivalence (#+ Equivalence)]]]})
-
-(def: #export (spec (^open "/@.") (^open "/@.") generator)
-  (All [m a] (-> (Equivalence a) (Codec m a) (Random a) Test))
-  (do r.monad
-    [expected generator]
-    (<| (_.context (%name (name-of /.Codec)))
-        (_.test "Isomorphism."
-                (case (|> expected /@encode /@decode)
-                  (#error.Success actual)
-                  (/@= expected actual)
-                  
-                  (#error.Failure error)
-                  false)))))
diff --git a/stdlib/source/test/lux/control/concurrency/actor.lux b/stdlib/source/test/lux/control/concurrency/actor.lux
index 014e4d758..eff4d051d 100644
--- a/stdlib/source/test/lux/control/concurrency/actor.lux
+++ b/stdlib/source/test/lux/control/concurrency/actor.lux
@@ -2,8 +2,8 @@
   [lux #*
    ["_" test (#+ Test)]
    ["." io (#+ IO io)]
+   [abstract/monad (#+ do)]
    [control
-    ["M" monad (#+ do Monad)]
     ["ex" exception]
     [concurrency
      ["." promise ("#;." monad)]]]
diff --git a/stdlib/source/test/lux/control/concurrency/atom.lux b/stdlib/source/test/lux/control/concurrency/atom.lux
index 29cc28ad4..455f8b00d 100644
--- a/stdlib/source/test/lux/control/concurrency/atom.lux
+++ b/stdlib/source/test/lux/control/concurrency/atom.lux
@@ -2,8 +2,7 @@
   [lux #*
    ["_" test (#+ Test)]
    ["." io]
-   [control
-    [monad (#+ do)]]
+   [abstract/monad (#+ do)]
    data/text/format
    [math
     ["r" random]]]
diff --git a/stdlib/source/test/lux/control/concurrency/frp.lux b/stdlib/source/test/lux/control/concurrency/frp.lux
index 92e4838a8..7ac79b465 100644
--- a/stdlib/source/test/lux/control/concurrency/frp.lux
+++ b/stdlib/source/test/lux/control/concurrency/frp.lux
@@ -2,8 +2,8 @@
   [lux #*
    ["_" test (#+ Test)]
    ["." io (#+ IO io)]
+   [abstract/monad (#+ do)]
    [control
-    ["." monad (#+ do)]
     [concurrency
      ["." promise ("#@." monad)]
      ["." atom (#+ Atom atom)]]]
diff --git a/stdlib/source/test/lux/control/concurrency/promise.lux b/stdlib/source/test/lux/control/concurrency/promise.lux
index 952e8fb7a..5a49f26fe 100644
--- a/stdlib/source/test/lux/control/concurrency/promise.lux
+++ b/stdlib/source/test/lux/control/concurrency/promise.lux
@@ -2,8 +2,8 @@
   [lux #*
    ["_" test (#+ Test)]
    ["." io]
+   [abstract/monad (#+ do)]
    [control
-    [monad (#+ Monad do)]
     pipe]
    data/text/format
    [math
diff --git a/stdlib/source/test/lux/control/concurrency/semaphore.lux b/stdlib/source/test/lux/control/concurrency/semaphore.lux
index 4aa4b08a5..40bd81364 100644
--- a/stdlib/source/test/lux/control/concurrency/semaphore.lux
+++ b/stdlib/source/test/lux/control/concurrency/semaphore.lux
@@ -1,7 +1,8 @@
 (.module:
   [lux #*
+   [abstract
+    ["." monad (#+ do)]]
    [control
-    ["." monad (#+ do)]
     [concurrency
      ["/" semaphore]
      ["." promise (#+ Promise)]
diff --git a/stdlib/source/test/lux/control/concurrency/stm.lux b/stdlib/source/test/lux/control/concurrency/stm.lux
index 52107f6fe..9e3b9290c 100644
--- a/stdlib/source/test/lux/control/concurrency/stm.lux
+++ b/stdlib/source/test/lux/control/concurrency/stm.lux
@@ -2,8 +2,8 @@
   [lux #*
    ["_" test (#+ Test)]
    ["." io (#+ IO)]
+   ["M" abstract/monad (#+ do Monad)]
    [control
-    ["M" monad (#+ do Monad)]
     [concurrency
      ["." atom (#+ Atom atom)]
      ["." process]
diff --git a/stdlib/source/test/lux/control/continuation.lux b/stdlib/source/test/lux/control/continuation.lux
index b676c67ff..571225ecc 100644
--- a/stdlib/source/test/lux/control/continuation.lux
+++ b/stdlib/source/test/lux/control/continuation.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/control/enum.lux b/stdlib/source/test/lux/control/enum.lux
deleted file mode 100644
index 5c7832260..000000000
--- a/stdlib/source/test/lux/control/enum.lux
+++ /dev/null
@@ -1,28 +0,0 @@
-(.module:
-  [lux #*
-   data/text/format
-   ["_" test (#+ Test)]
-   ["." function]
-   [control
-    [monad (#+ do)]]
-   [math
-    ["r" random (#+ Random)]]]
-  {1
-   ["." / (#+ Enum)]})
-
-(def: #export (spec (^open "/@.") gen-sample)
-  (All [a] (-> (Enum a) (Random a) Test))
-  (do r.monad
-    [sample gen-sample]
-    (<| (_.context (%name (name-of /.Order)))
-        ($_ _.and
-            (_.test "Successor and predecessor are inverse functions."
-                    (and (/@= (|> sample /@succ /@pred)
-                              (function.identity sample))
-                         (/@= (|> sample /@pred /@succ)
-                              (function.identity sample))
-                         (not (/@= (|> sample /@succ)
-                                   (function.identity sample)))
-                         (not (/@= (|> sample /@pred)
-                                   (function.identity sample)))))
-            ))))
diff --git a/stdlib/source/test/lux/control/equivalence.lux b/stdlib/source/test/lux/control/equivalence.lux
deleted file mode 100644
index 3e3b91a04..000000000
--- a/stdlib/source/test/lux/control/equivalence.lux
+++ /dev/null
@@ -1,26 +0,0 @@
-(.module:
-  [lux #*
-   ["_" test (#+ Test)]
-   [control
-    [monad (#+ do)]]
-   [data
-    [text
-     format]]
-   [math
-    ["r" random (#+ Random)]]]
-  {1
-   ["." / (#+ Equivalence)]})
-
-(def: #export (spec (^open "_@.") generator)
-  (All [a] (-> (Equivalence a) (Random a) Test))
-  (do r.monad
-    [left generator
-     right generator]
-    (<| (_.context (%name (name-of /.Equivalence)))
-        ($_ _.and
-            (_.test "Reflexivity."
-                    (_@= left left))
-            (_.test "Symmetry."
-                    (if (_@= left right)
-                      (_@= right left)
-                      (not (_@= right left))))))))
diff --git a/stdlib/source/test/lux/control/exception.lux b/stdlib/source/test/lux/control/exception.lux
index c56688af3..7b7d90dbf 100644
--- a/stdlib/source/test/lux/control/exception.lux
+++ b/stdlib/source/test/lux/control/exception.lux
@@ -1,7 +1,6 @@
 (.module:
   [lux #*
-   [control
-    [monad (#+ do)]]
+   [abstract/monad (#+ do)]
    [data
     [text
      format]]
diff --git a/stdlib/source/test/lux/control/fold.lux b/stdlib/source/test/lux/control/fold.lux
deleted file mode 100644
index 7d7ea8d83..000000000
--- a/stdlib/source/test/lux/control/fold.lux
+++ /dev/null
@@ -1,21 +0,0 @@
-(.module:
-  [lux #*
-   ["_" test (#+ Test)]
-   data/text/format
-   ["r" math/random]
-   [control
-    [monad (#+ do)]]]
-  [//
-   [functor (#+ Injection Comparison)]]
-  {1
-   ["." / (#+ Fold)]})
-
-(def: #export (spec injection comparison (^open "/@."))
-  (All [f] (-> (Injection f) (Comparison f) (Fold f) Test))
-  (_.context (%name (name-of /.Fold))
-             (do r.monad
-               [subject r.nat
-                parameter r.nat]
-               (_.test "Can fold."
-                       (n/= (/@fold n/+ parameter (injection subject))
-                            (n/+ parameter subject))))))
diff --git a/stdlib/source/test/lux/control/functor.lux b/stdlib/source/test/lux/control/functor.lux
deleted file mode 100644
index 68c8db55b..000000000
--- a/stdlib/source/test/lux/control/functor.lux
+++ /dev/null
@@ -1,58 +0,0 @@
-(.module:
-  [lux #*
-   ["_" test (#+ Test)]
-   data/text/format
-   ["r" math/random]
-   [control
-    [equivalence (#+ Equivalence)]
-    [monad (#+ do)]]
-   ["." function]]
-  {1
-   ["." / (#+ Functor)]})
-
-(type: #export (Injection f)
-  (All [a] (-> a (f a))))
-
-(type: #export (Comparison f)
-  (All [a]
-    (-> (Equivalence a)
-        (Equivalence (f a)))))
-
-(def: (identity injection comparison (^open "/@."))
-  (All [f] (-> (Injection f) (Comparison f) (Functor f) Test))
-  (do r.monad
-    [sample (:: @ map injection r.nat)]
-    (_.test "Identity."
-            ((comparison n/=)
-             (/@map function.identity sample)
-             sample))))
-
-(def: (homomorphism injection comparison (^open "/@."))
-  (All [f] (-> (Injection f) (Comparison f) (Functor f) Test))
-  (do r.monad
-    [sample r.nat
-     increase (:: @ map n/+ r.nat)]
-    (_.test "Homomorphism."
-            ((comparison n/=)
-             (/@map increase (injection sample))
-             (injection (increase sample))))))
-
-(def: (composition injection comparison (^open "/@."))
-  (All [f] (-> (Injection f) (Comparison f) (Functor f) Test))
-  (do r.monad
-    [sample (:: @ map injection r.nat)
-     increase (:: @ map n/+ r.nat)
-     decrease (:: @ map n/- r.nat)]
-    (_.test "Composition."
-            ((comparison n/=)
-             (|> sample (/@map increase) (/@map decrease))
-             (|> sample (/@map (|>> increase decrease)))))))
-
-(def: #export (spec injection comparison functor)
-  (All [f] (-> (Injection f) (Comparison f) (Functor f) Test))
-  (_.context (%name (name-of /.Functor))
-             ($_ _.and
-                 (..identity injection comparison functor)
-                 (..homomorphism injection comparison functor)
-                 (..composition injection comparison functor)
-                 )))
diff --git a/stdlib/source/test/lux/control/interval.lux b/stdlib/source/test/lux/control/interval.lux
deleted file mode 100644
index 7502f88bc..000000000
--- a/stdlib/source/test/lux/control/interval.lux
+++ /dev/null
@@ -1,249 +0,0 @@
-(.module:
-  [lux #*
-   ["_" test (#+ Test)]
-   [control
-    [pipe (#+ case>)]
-    [monad (#+ do)]]
-   [data
-    [number
-     ["." nat]]
-    [text
-     format]
-    [collection
-     ["." set]
-     ["." list]]]
-   [math
-    ["r" random (#+ Random)]]]
-  {1
-   ["." / (#+ Interval) ("_@." equivalence)]}
-  {0
-   [test
-    [lux
-     [control
-      ["$." equivalence]]]]})
-
-(template [<name> <cmp>]
-  [(def: #export <name>
-     (Random (Interval Nat))
-     (do r.monad
-       [bottom r.nat
-        top (|> r.nat (r.filter (|>> (n/= bottom) not)))]
-       (if (<cmp> top bottom)
-         (wrap (/.between nat.enum bottom top))
-         (wrap (/.between nat.enum top bottom)))))]
-
-  [inner n/<]
-  [outer n/>]
-  )
-
-(def: #export singleton
-  (Random (Interval Nat))
-  (do r.monad
-    [point r.nat]
-    (wrap (/.singleton nat.enum point))))
-
-(def: #export interval
-  (Random (Interval Nat))
-  ($_ r.either
-      ..inner
-      ..outer
-      ..singleton))
-
-(def: boundaries
-  Test
-  (do r.monad
-    [bottom r.nat
-     top r.nat
-     #let [interval (/.between nat.enum bottom top)]]
-    ($_ _.and
-        (_.test "A boundary value belongs to its interval."
-                (and (/.within? interval bottom)
-                     (/.within? interval top)))
-        (_.test "An interval starts with its bottom."
-                (/.starts-with? bottom interval))
-        (_.test "An interval ends with its top."
-                (/.ends-with? top interval))
-        (_.test "The boundary values border the interval."
-                (and (/.borders? interval bottom)
-                     (/.borders? interval top)))
-        )))
-
-(def: union
-  Test
-  (do r.monad
-    [some-interval ..interval
-     left-inner ..inner
-     right-inner ..inner
-     left-singleton ..singleton
-     right-singleton ..singleton
-     left-outer ..outer
-     right-outer ..outer]
-    ($_ _.and
-        (_.test "The union of an interval to itself yields the same interval."
-                (_@= some-interval (/.union some-interval some-interval)))
-        (_.test "The union of 2 inner intervals is another inner interval."
-                (/.inner? (/.union left-inner right-inner)))
-        (_.test "The union of 2 outer intervals yields an inner interval when their complements don't overlap, and an outer when they do."
-                (if (/.overlaps? (/.complement left-outer) (/.complement right-outer))
-                  (/.outer? (/.union left-outer right-outer))
-                  (/.inner? (/.union left-outer right-outer))))
-        )))
-
-(def: intersection
-  Test
-  (do r.monad
-    [some-interval ..interval
-     left-inner ..inner
-     right-inner ..inner
-     left-singleton ..singleton
-     right-singleton ..singleton
-     left-outer ..outer
-     right-outer ..outer]
-    ($_ _.and
-        (_.test "The intersection of an interval to itself yields the same interval."
-                (_@= some-interval (/.intersection some-interval some-interval)))
-        (_.test "The intersection of 2 inner intervals yields an inner interval when they overlap, and an outer when they don't."
-                (if (/.overlaps? left-inner right-inner)
-                  (/.inner? (/.intersection left-inner right-inner))
-                  (/.outer? (/.intersection left-inner right-inner))))
-        (_.test "The intersection of 2 outer intervals is another outer interval."
-                (/.outer? (/.intersection left-outer right-outer)))
-        )))
-
-(def: complement
-  Test
-  (do r.monad
-    [some-interval ..interval]
-    ($_ _.and
-        (_.test "The complement of a complement is the same as the original."
-                (_@= some-interval (|> some-interval /.complement /.complement)))
-        (_.test "The complement of an interval does not overlap it."
-                (not (/.overlaps? some-interval (/.complement some-interval))))
-        )))
-
-(def: location
-  Test
-  (do r.monad
-    [[l m r] (|> (r.set nat.hash 3 r.nat)
-                 (:: @ map (|>> set.to-list
-                                (list.sort n/<)
-                                (case> (^ (list b t1 t2))
-                                       [b t1 t2]
-
-                                       _
-                                       (undefined)))))
-     #let [left (/.singleton nat.enum l)
-           right (/.singleton nat.enum r)]]
-    ($_ _.and
-        (_.test "'precedes?' and 'succeeds?' are symetric."
-                (and (/.precedes? right left)
-                     (/.succeeds? left right)))
-        (_.test "Can check if an interval is before or after some element."
-                (and (/.before? m left)
-                     (/.after? m right)))
-        )))
-
-(def: touch
-  Test
-  (do r.monad
-    [[b t1 t2] (|> (r.set nat.hash 3 r.nat)
-                   (:: @ map (|>> set.to-list
-                                  (list.sort n/<)
-                                  (case> (^ (list b t1 t2))
-                                         [b t1 t2]
-
-                                         _
-                                         (undefined)))))
-     #let [int-left (/.between nat.enum t1 t2)
-           int-right (/.between nat.enum b t1)]]
-    ($_ _.and
-        (_.test "An interval meets another if its top is the other's bottom."
-                (/.meets? int-left int-right))
-        (_.test "Two intervals touch one another if any one meets the other."
-                (/.touches? int-left int-right))
-        (_.test "Can check if 2 intervals start together."
-                (/.starts? (/.between nat.enum b t2)
-                           (/.between nat.enum b t1)))
-        (_.test "Can check if 2 intervals finish together."
-                (/.finishes? (/.between nat.enum b t2)
-                             (/.between nat.enum t1 t2)))
-        )))
-
-(def: overlap
-  Test
-  (do r.monad
-    [some-interval ..interval
-     [x0 x1 x2 x3] (|> (r.set nat.hash 4 r.nat)
-                       (:: @ map (|>> set.to-list
-                                      (list.sort n/<)
-                                      (case> (^ (list x0 x1 x2 x3))
-                                             [x0 x1 x2 x3]
-
-                                             _
-                                             (undefined)))))]
-    ($_ _.and
-        (_.test "Every interval is nested into itself."
-                (/.nested? some-interval some-interval))
-        (_.test "No interval overlaps with itself."
-                (not (/.overlaps? some-interval some-interval)))
-        (let [small-inner (/.between nat.enum x1 x2)
-              large-inner (/.between nat.enum x0 x3)]
-          (_.test "Inner intervals can be nested inside one another."
-                  (and (/.nested? large-inner small-inner)
-                       (not (/.nested? small-inner large-inner)))))
-        (let [left-inner (/.between nat.enum x0 x2)
-              right-inner (/.between nat.enum x1 x3)]
-          (_.test "Inner intervals can overlap one another."
-                  (and (/.overlaps? left-inner right-inner)
-                       (/.overlaps? right-inner left-inner))))
-        (let [small-outer (/.between nat.enum x2 x1)
-              large-outer (/.between nat.enum x3 x0)]
-          (_.test "Outer intervals can be nested inside one another."
-                  (and (/.nested? small-outer large-outer)
-                       (not (/.nested? large-outer small-outer)))))
-        (let [left-inner (/.between nat.enum x0 x1)
-              right-inner (/.between nat.enum x2 x3)
-              outer (/.between nat.enum x0 x3)]
-          (_.test "Inners can be nested inside outers."
-                  (and (/.nested? outer left-inner)
-                       (/.nested? outer right-inner))))
-        (let [left-inner (/.between nat.enum x0 x2)
-              right-inner (/.between nat.enum x1 x3)
-              outer (/.between nat.enum x1 x2)]
-          (_.test "Inners can overlap outers."
-                  (and (/.overlaps? outer left-inner)
-                       (/.overlaps? outer right-inner))))
-        )))
-
-(def: #export test
-  Test
-  (<| (_.context (%name (name-of /.Interval)))
-      ($_ _.and
-          ($equivalence.spec /.equivalence ..interval)
-          (<| (_.context "Boundaries.")
-              ..boundaries)
-          (<| (_.context "Union.")
-              ..union)
-          (<| (_.context "Intersection.")
-              ..intersection)
-          (<| (_.context "Complement.")
-              ..complement)
-          (<| (_.context "Positioning/location.")
-              ..location)
-          (<| (_.context "Touching intervals.")
-              ..touch)
-          (<| (_.context "Nesting & overlap.")
-              ..overlap)
-          )))
-
-(def: #export (spec (^open "_@.") gen-sample)
-  (All [a] (-> (Interval a) (Random a) Test))
-  (<| (_.context (%name (name-of /.Interval)))
-      (do r.monad
-        [sample gen-sample]
-        ($_ _.and
-            (_.test "No value is bigger than the top."
-                    (_@< _@top sample))
-            (_.test "No value is smaller than the bottom."
-                    (_@> _@bottom sample))
-            ))))
diff --git a/stdlib/source/test/lux/control/monad.lux b/stdlib/source/test/lux/control/monad.lux
deleted file mode 100644
index 4382a260d..000000000
--- a/stdlib/source/test/lux/control/monad.lux
+++ /dev/null
@@ -1,58 +0,0 @@
-(.module:
-  [lux #*
-   [data
-    [text
-     format]]
-   ["." function]
-   [math
-    ["r" random]]
-   ["_" test (#+ Test)]]
-  {1
-   ["." / (#+ Monad do)]}
-  [//
-   [functor (#+ Injection Comparison)]])
-
-(def: (left-identity injection comparison (^open "_;."))
-  (All [f] (-> (Injection f) (Comparison f) (Monad f) Test))
-  (do r.monad
-    [sample r.nat
-     morphism (:: @ map (function (_ diff)
-                          (|>> (n/+ diff) _;wrap))
-                  r.nat)]
-    (_.test "Left identity."
-            ((comparison n/=)
-             (|> (injection sample) (_;map morphism) _;join)
-             (morphism sample)))))
-
-(def: (right-identity injection comparison (^open "_;."))
-  (All [f] (-> (Injection f) (Comparison f) (Monad f) Test))
-  (do r.monad
-    [sample r.nat]
-    (_.test "Right identity."
-            ((comparison n/=)
-             (|> (injection sample) (_;map _;wrap) _;join)
-             (injection sample)))))
-
-(def: (associativity injection comparison (^open "_;."))
-  (All [f] (-> (Injection f) (Comparison f) (Monad f) Test))
-  (do r.monad
-    [sample r.nat
-     increase (:: @ map (function (_ diff)
-                          (|>> (n/+ diff) _;wrap))
-                  r.nat)
-     decrease (:: @ map (function (_ diff)
-                          (|>> (n/- diff) _;wrap))
-                  r.nat)]
-    (_.test "Associativity."
-            ((comparison n/=)
-             (|> (injection sample) (_;map increase) _;join (_;map decrease) _;join)
-             (|> (injection sample) (_;map (|>> increase (_;map decrease) _;join)) _;join)))))
-
-(def: #export (spec injection comparison monad)
-  (All [f] (-> (Injection f) (Comparison f) (Monad f) Test))
-  (_.context (%name (name-of /.Monad))
-             ($_ _.and
-                 (..left-identity injection comparison monad)
-                 (..right-identity injection comparison monad)
-                 (..associativity injection comparison monad)
-                 )))
diff --git a/stdlib/source/test/lux/control/monoid.lux b/stdlib/source/test/lux/control/monoid.lux
deleted file mode 100644
index b12262900..000000000
--- a/stdlib/source/test/lux/control/monoid.lux
+++ /dev/null
@@ -1,25 +0,0 @@
-(.module:
-  [lux #*
-   data/text/format
-   ["_" test (#+ Test)]
-   ["." function]
-   [control
-    [monad (#+ do)]]
-   [math
-    ["r" random (#+ Random)]]]
-  {1
-   ["." / (#+ Monoid)
-    [//
-     [equivalence (#+ Equivalence)]]]})
-
-(def: #export (spec (^open "/@.") (^open "/@.") gen-sample)
-  (All [a] (-> (Equivalence a) (Monoid a) (Random a) Test))
-  (do r.monad
-    [sample gen-sample]
-    (<| (_.context (%name (name-of /.Monoid)))
-        ($_ _.and
-            (_.test "Left identity."
-                    (/@= sample (/@compose /@identity sample)))
-            (_.test "Right identity."
-                    (/@= sample (/@compose sample /@identity)))
-            ))))
diff --git a/stdlib/source/test/lux/control/number.lux b/stdlib/source/test/lux/control/number.lux
deleted file mode 100644
index 57bee6ee3..000000000
--- a/stdlib/source/test/lux/control/number.lux
+++ /dev/null
@@ -1,47 +0,0 @@
-(.module:
-  [lux #*
-   ["_" test (#+ Test)]
-   [control
-    [monad (#+ do)]]
-   [data
-    [text
-     format]]
-   [math
-    ["r" random (#+ Random)]]]
-  {1
-   ["." / (#+ Number)
-    [//
-     [order (#+ Order)]]]})
-
-(def: #export (spec (^open "/@.") (^open "/@.") gen-sample)
-  (All [a] (-> (Order a) (Number a) (Random a) Test))
-  (do r.monad
-    [#let [non-zero (r.filter (function (_ sample)
-                                (|> sample (/@+ sample) (/@= sample) not))
-                              gen-sample)]
-     parameter non-zero
-     subject non-zero]
-    (<| (_.context (%name (name-of /.Number)))
-        ($_ _.and
-            (_.test "Addition and subtraction are inverse functions."
-                    (|> subject (/@+ parameter) (/@- parameter) (/@= subject)))
-            (_.test "Multiplication and division are inverse functions."
-                    (|> subject (/@* parameter) (/@/ parameter) (/@= subject)))
-            (_.test "Modulus fills all the information division misses."
-                    (let [modulus (/@% parameter subject)
-                          multiple (/@- modulus subject)
-                          factor (/@/ parameter multiple)]
-                      (|> parameter (/@* factor) (/@+ modulus) (/@= subject))))
-            (_.test "Negation flips the sign of a number and mimics subtraction."
-                    (let [unsigned? (/@= (/@signum parameter)
-                                         (/@signum (/@negate parameter)))]
-                      (or unsigned?
-                          (/@= (/@+ (/@negate parameter) subject)
-                               (/@- parameter subject)))))
-            (_.test "The absolute value is always positive."
-                    (let [unsigned? (/@= parameter
-                                         (/@negate parameter))]
-                      (if unsigned?
-                        (/@= subject (/@abs subject))
-                        (/@>= subject (/@abs subject)))))
-            ))))
diff --git a/stdlib/source/test/lux/control/order.lux b/stdlib/source/test/lux/control/order.lux
deleted file mode 100644
index f18d110c2..000000000
--- a/stdlib/source/test/lux/control/order.lux
+++ /dev/null
@@ -1,27 +0,0 @@
-(.module:
-  [lux #*
-   ["_" test (#+ Test)]
-   [control
-    [monad (#+ do)]]
-   [data
-    [text
-     format]]
-   [math
-    ["r" random (#+ Random)]]]
-  {1
-   ["." / (#+ Order)]})
-
-(def: #export (spec (^open ",@.") generator)
-  (All [a] (-> (Order a) (Random a) Test))
-  (do r.monad
-    [left generator
-     right generator]
-    (<| (_.context (%name (name-of /.Order)))
-        ($_ _.and
-            (_.test "Values are either ordered, or they are equal. All options are mutually exclusive."
-                    (if (,@= left right)
-                      (not (or (,@< left right)
-                               (,@> left right)))
-                      (if (,@< left right)
-                        (not (,@> left right))
-                        (,@> left right))))))))
diff --git a/stdlib/source/test/lux/control/parser.lux b/stdlib/source/test/lux/control/parser.lux
index a5d8fb0c2..da6c0a381 100644
--- a/stdlib/source/test/lux/control/parser.lux
+++ b/stdlib/source/test/lux/control/parser.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     [equivalence (#+ Equivalence)]
     {[0 #test]
diff --git a/stdlib/source/test/lux/control/pipe.lux b/stdlib/source/test/lux/control/pipe.lux
index fda914291..6f7b65a53 100644
--- a/stdlib/source/test/lux/control/pipe.lux
+++ b/stdlib/source/test/lux/control/pipe.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]]
    [data
     ["." identity]
diff --git a/stdlib/source/test/lux/control/reader.lux b/stdlib/source/test/lux/control/reader.lux
index 59763c0e8..aa639ce70 100644
--- a/stdlib/source/test/lux/control/reader.lux
+++ b/stdlib/source/test/lux/control/reader.lux
@@ -2,7 +2,7 @@
   [lux #*
    ["." io (#+ IO)]
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/control/region.lux b/stdlib/source/test/lux/control/region.lux
index cca103eac..a575e4250 100644
--- a/stdlib/source/test/lux/control/region.lux
+++ b/stdlib/source/test/lux/control/region.lux
@@ -1,8 +1,9 @@
 (.module:
   [lux #*
    ["_" test (#+ Test)]
+   [abstract
+    ["." monad (#+ do)]]
    [control
-    ["." monad (#+ do)]
     ["." thread (#+ Thread)]
     ["ex" exception (#+ exception:)]]
    [data
diff --git a/stdlib/source/test/lux/control/security/integrity.lux b/stdlib/source/test/lux/control/security/integrity.lux
index ad9b67f4f..77e0505d6 100644
--- a/stdlib/source/test/lux/control/security/integrity.lux
+++ b/stdlib/source/test/lux/control/security/integrity.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [hash (#+ Hash)]
     [monad (#+ do)]
     {[0 #test]
diff --git a/stdlib/source/test/lux/control/security/privacy.lux b/stdlib/source/test/lux/control/security/privacy.lux
index 3bc41e6a9..3b167e0d2 100644
--- a/stdlib/source/test/lux/control/security/privacy.lux
+++ b/stdlib/source/test/lux/control/security/privacy.lux
@@ -1,16 +1,17 @@
 (.module:
   [lux #*
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [hash (#+ Hash)]
     [monad (#+ do)]
-    [security
-     ["!" capability]]
     {[0 #test]
      [/
       ["$." functor (#+ Injection Comparison)]
       ["$." apply]
       ["$." monad]]}]
+   [control
+    [security
+     ["!" capability]]]
    [data
     ["." text ("#;." equivalence)
      format]]
diff --git a/stdlib/source/test/lux/control/state.lux b/stdlib/source/test/lux/control/state.lux
index 8bae5e472..808d5ebb2 100644
--- a/stdlib/source/test/lux/control/state.lux
+++ b/stdlib/source/test/lux/control/state.lux
@@ -2,14 +2,15 @@
   [lux #*
    ["_" test (#+ Test)]
    ["." io]
-   [control
-    [pipe (#+ let>)]
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
       ["$." functor (#+ Injection Comparison)]
       ["$." apply]
       ["$." monad]]}]
+   [control
+    [pipe (#+ let>)]]
    [data
     ["." product]
     [text
diff --git a/stdlib/source/test/lux/control/thread.lux b/stdlib/source/test/lux/control/thread.lux
index a6f28e428..56d3a7d5c 100644
--- a/stdlib/source/test/lux/control/thread.lux
+++ b/stdlib/source/test/lux/control/thread.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/control/writer.lux b/stdlib/source/test/lux/control/writer.lux
index dfd3b4a10..392fc7a4b 100644
--- a/stdlib/source/test/lux/control/writer.lux
+++ b/stdlib/source/test/lux/control/writer.lux
@@ -2,7 +2,7 @@
   [lux #*
    ["_" test (#+ Test)]
    ["." io]
-   [control
+   [abstract
     [equivalence (#+ Equivalence)]
     [monoid (#+ Monoid)]
     [monad (#+ do)]
diff --git a/stdlib/source/test/lux/data/bit.lux b/stdlib/source/test/lux/data/bit.lux
index f6ad5e727..9515fa5ce 100644
--- a/stdlib/source/test/lux/data/bit.lux
+++ b/stdlib/source/test/lux/data/bit.lux
@@ -4,7 +4,7 @@
    ["_" test (#+ Test)]
    ["r" math/random]
    ["." function]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/collection/array.lux b/stdlib/source/test/lux/data/collection/array.lux
index 8814a6e88..c210a9163 100644
--- a/stdlib/source/test/lux/data/collection/array.lux
+++ b/stdlib/source/test/lux/data/collection/array.lux
@@ -2,8 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
-    pipe
+   [abstract
     [monad (#+ do Monad)]
     {[0 #test]
      [/
@@ -11,6 +10,8 @@
       ["$." monoid]
       ["$." fold]
       ["$." functor (#+ Injection)]]}]
+   [control
+    pipe]
    [data
     ["." maybe]
     [number
diff --git a/stdlib/source/test/lux/data/collection/bits.lux b/stdlib/source/test/lux/data/collection/bits.lux
index ac7e983f9..a727761ca 100644
--- a/stdlib/source/test/lux/data/collection/bits.lux
+++ b/stdlib/source/test/lux/data/collection/bits.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     ["." predicate]
     {[0 #test]
diff --git a/stdlib/source/test/lux/data/collection/dictionary.lux b/stdlib/source/test/lux/data/collection/dictionary.lux
index e559a2453..863c47973 100644
--- a/stdlib/source/test/lux/data/collection/dictionary.lux
+++ b/stdlib/source/test/lux/data/collection/dictionary.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     ["eq" equivalence]
     {[0 #test]
diff --git a/stdlib/source/test/lux/data/collection/dictionary/ordered.lux b/stdlib/source/test/lux/data/collection/dictionary/ordered.lux
index 4cd7880ba..57dab9884 100644
--- a/stdlib/source/test/lux/data/collection/dictionary/ordered.lux
+++ b/stdlib/source/test/lux/data/collection/dictionary/ordered.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     [equivalence (#+ Equivalence)]
     [order (#+ Order)]
diff --git a/stdlib/source/test/lux/data/collection/list.lux b/stdlib/source/test/lux/data/collection/list.lux
index 958025e8b..247b2de78 100644
--- a/stdlib/source/test/lux/data/collection/list.lux
+++ b/stdlib/source/test/lux/data/collection/list.lux
@@ -3,8 +3,7 @@
    data/text/format
    ["_" test (#+ Test)]
    ["." io]
-   [control
-    pipe
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
@@ -14,6 +13,8 @@
       ["$." functor]
       ["$." apply]
       ["$." monad]]}]
+   [control
+    pipe]
    [data
     ["." bit]
     ["." product]
diff --git a/stdlib/source/test/lux/data/collection/queue.lux b/stdlib/source/test/lux/data/collection/queue.lux
index c377fccc3..506cf15e3 100644
--- a/stdlib/source/test/lux/data/collection/queue.lux
+++ b/stdlib/source/test/lux/data/collection/queue.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/collection/queue/priority.lux b/stdlib/source/test/lux/data/collection/queue/priority.lux
index df24b8368..4c4f2923a 100644
--- a/stdlib/source/test/lux/data/collection/queue/priority.lux
+++ b/stdlib/source/test/lux/data/collection/queue/priority.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     ["." monad (#+ do)]]
    [data
     ["." maybe]
diff --git a/stdlib/source/test/lux/data/collection/row.lux b/stdlib/source/test/lux/data/collection/row.lux
index 1fa55e135..15085776b 100644
--- a/stdlib/source/test/lux/data/collection/row.lux
+++ b/stdlib/source/test/lux/data/collection/row.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/collection/sequence.lux b/stdlib/source/test/lux/data/collection/sequence.lux
index edacef996..6b4529dfc 100644
--- a/stdlib/source/test/lux/data/collection/sequence.lux
+++ b/stdlib/source/test/lux/data/collection/sequence.lux
@@ -2,9 +2,9 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     comonad
-    [monad (#+ do Monad)]]
+    [monad (#+ do)]]
    [data
     ["." maybe]
     [number
diff --git a/stdlib/source/test/lux/data/collection/set.lux b/stdlib/source/test/lux/data/collection/set.lux
index f319af295..f272cf305 100644
--- a/stdlib/source/test/lux/data/collection/set.lux
+++ b/stdlib/source/test/lux/data/collection/set.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/collection/set/ordered.lux b/stdlib/source/test/lux/data/collection/set/ordered.lux
index 7f143a9cd..4bddfaf33 100644
--- a/stdlib/source/test/lux/data/collection/set/ordered.lux
+++ b/stdlib/source/test/lux/data/collection/set/ordered.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     [order (#+ Order)]
     {[0 #test]
diff --git a/stdlib/source/test/lux/data/collection/stack.lux b/stdlib/source/test/lux/data/collection/stack.lux
index 2886fa815..05b8efc47 100644
--- a/stdlib/source/test/lux/data/collection/stack.lux
+++ b/stdlib/source/test/lux/data/collection/stack.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/collection/tree/rose.lux b/stdlib/source/test/lux/data/collection/tree/rose.lux
index 987a72f45..65b46e382 100644
--- a/stdlib/source/test/lux/data/collection/tree/rose.lux
+++ b/stdlib/source/test/lux/data/collection/tree/rose.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/collection/tree/rose/zipper.lux b/stdlib/source/test/lux/data/collection/tree/rose/zipper.lux
index 3a3bd296c..e8f59a43a 100644
--- a/stdlib/source/test/lux/data/collection/tree/rose/zipper.lux
+++ b/stdlib/source/test/lux/data/collection/tree/rose/zipper.lux
@@ -2,8 +2,8 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
+   [abstract/monad (#+ do Monad)]
    [control
-    [monad (#+ do Monad)]
     pipe]
    [data
     ["." maybe]
diff --git a/stdlib/source/test/lux/data/color.lux b/stdlib/source/test/lux/data/color.lux
index f3db0c6f7..a8a61cb46 100644
--- a/stdlib/source/test/lux/data/color.lux
+++ b/stdlib/source/test/lux/data/color.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/error.lux b/stdlib/source/test/lux/data/error.lux
index c60c6563a..8f89ccb8f 100644
--- a/stdlib/source/test/lux/data/error.lux
+++ b/stdlib/source/test/lux/data/error.lux
@@ -2,8 +2,7 @@
   [lux #*
    ["_" test (#+ Test)]
    ["." io]
-   [control
-    pipe
+   [abstract
     [monad (#+ do Monad)]
     {[0 #test]
      [/
@@ -11,6 +10,8 @@
       ["$." apply]
       ["$." monad]
       ["$." equivalence]]}]
+   [control
+    pipe]
    [data
     text/format
     [number
diff --git a/stdlib/source/test/lux/data/format/json.lux b/stdlib/source/test/lux/data/format/json.lux
index f276c5180..c2826143a 100644
--- a/stdlib/source/test/lux/data/format/json.lux
+++ b/stdlib/source/test/lux/data/format/json.lux
@@ -2,16 +2,17 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
-    pipe
+   [abstract
     codec
     [monad (#+ do Monad)]
     [equivalence (#+ Equivalence)]
-    ["p" parser]
     {[0 #test]
      [/
       ["$." equivalence]
       ["$." codec]]}]
+   [control
+    pipe
+    ["p" parser]]
    [data
     ["." error]
     ["." bit]
diff --git a/stdlib/source/test/lux/data/format/xml.lux b/stdlib/source/test/lux/data/format/xml.lux
index 221edba97..cf2b10f65 100644
--- a/stdlib/source/test/lux/data/format/xml.lux
+++ b/stdlib/source/test/lux/data/format/xml.lux
@@ -2,14 +2,15 @@
   [lux (#- char)
    data/text/format
    ["_" test (#+ Test)]
-   [control
-    pipe
+   [abstract
     [monad (#+ Monad do)]
-    ["p" parser]
     {[0 #test]
      [/
       ["$." equivalence]
       ["$." codec]]}]
+   [control
+    pipe
+    ["p" parser]]
    [data
     ["." name]
     ["E" error]
diff --git a/stdlib/source/test/lux/data/identity.lux b/stdlib/source/test/lux/data/identity.lux
index ef4450c50..38d20a7d5 100644
--- a/stdlib/source/test/lux/data/identity.lux
+++ b/stdlib/source/test/lux/data/identity.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    ["_" test (#+ Test)]
-   [control
+   [abstract
     comonad
     [monad (#+ do)]
     {[0 #test]
diff --git a/stdlib/source/test/lux/data/lazy.lux b/stdlib/source/test/lux/data/lazy.lux
index 44c0ff2da..62b1273e4 100644
--- a/stdlib/source/test/lux/data/lazy.lux
+++ b/stdlib/source/test/lux/data/lazy.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/maybe.lux b/stdlib/source/test/lux/data/maybe.lux
index 4aa89f85f..dc6ca1d56 100644
--- a/stdlib/source/test/lux/data/maybe.lux
+++ b/stdlib/source/test/lux/data/maybe.lux
@@ -1,8 +1,7 @@
 (.module:
   [lux #*
    ["_" test (#+ Test)]
-   [control
-    pipe
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
@@ -10,6 +9,8 @@
       ["$." functor]
       ["$." apply]
       ["$." monad]]}]
+   [control
+    pipe]
    [data
     ["." text
      format]
diff --git a/stdlib/source/test/lux/data/name.lux b/stdlib/source/test/lux/data/name.lux
index a42684938..d9ee517d0 100644
--- a/stdlib/source/test/lux/data/name.lux
+++ b/stdlib/source/test/lux/data/name.lux
@@ -1,13 +1,14 @@
 (.module:
   [lux #*
    ["_" test (#+ Test)]
-   [control
-    pipe
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
       ["$." equivalence]
       ["$." codec]]}]
+   [control
+    pipe]
    [data
     ["." text ("#@." equivalence)
      format]]
diff --git a/stdlib/source/test/lux/data/number/complex.lux b/stdlib/source/test/lux/data/number/complex.lux
index a1fc7beca..8eed3e865 100644
--- a/stdlib/source/test/lux/data/number/complex.lux
+++ b/stdlib/source/test/lux/data/number/complex.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/number/frac.lux b/stdlib/source/test/lux/data/number/frac.lux
index 89ff72749..544ab858c 100644
--- a/stdlib/source/test/lux/data/number/frac.lux
+++ b/stdlib/source/test/lux/data/number/frac.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/number/i64.lux b/stdlib/source/test/lux/data/number/i64.lux
index 3e251d1e6..1519b1e48 100644
--- a/stdlib/source/test/lux/data/number/i64.lux
+++ b/stdlib/source/test/lux/data/number/i64.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/number/int.lux b/stdlib/source/test/lux/data/number/int.lux
index e11685580..5b0d523ae 100644
--- a/stdlib/source/test/lux/data/number/int.lux
+++ b/stdlib/source/test/lux/data/number/int.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/number/nat.lux b/stdlib/source/test/lux/data/number/nat.lux
index 9616e9bd6..4c46b4b0c 100644
--- a/stdlib/source/test/lux/data/number/nat.lux
+++ b/stdlib/source/test/lux/data/number/nat.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/number/ratio.lux b/stdlib/source/test/lux/data/number/ratio.lux
index c3c67c317..f0ce55751 100644
--- a/stdlib/source/test/lux/data/number/ratio.lux
+++ b/stdlib/source/test/lux/data/number/ratio.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/number/rev.lux b/stdlib/source/test/lux/data/number/rev.lux
index 15b98ffe6..308861368 100644
--- a/stdlib/source/test/lux/data/number/rev.lux
+++ b/stdlib/source/test/lux/data/number/rev.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/data/text.lux b/stdlib/source/test/lux/data/text.lux
index e3166dcd9..20ad838b7 100644
--- a/stdlib/source/test/lux/data/text.lux
+++ b/stdlib/source/test/lux/data/text.lux
@@ -2,13 +2,14 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
-    pipe
+   [abstract
     [monad (#+ do Monad)]
     {[0 #test]
      [/
       ["$." equivalence]
       ["$." order]]}]
+   [control
+    pipe]
    [data
     [collection
      ["." list]]]
diff --git a/stdlib/source/test/lux/data/text/lexer.lux b/stdlib/source/test/lux/data/text/lexer.lux
index b15a86846..3693b0fd0 100644
--- a/stdlib/source/test/lux/data/text/lexer.lux
+++ b/stdlib/source/test/lux/data/text/lexer.lux
@@ -2,9 +2,9 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
+   [abstract/monad (#+ do)]
    [control
     pipe
-    [monad (#+ do Monad)]
     ["p" parser]]
    [data
     ["." error (#+ Error)]
diff --git a/stdlib/source/test/lux/data/text/regex.lux b/stdlib/source/test/lux/data/text/regex.lux
index 059adff84..58ef21b8b 100644
--- a/stdlib/source/test/lux/data/text/regex.lux
+++ b/stdlib/source/test/lux/data/text/regex.lux
@@ -2,8 +2,8 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
+   [abstract/monad (#+ do)]
    [control
-    [monad (#+ do Monad)]
     pipe
     ["p" parser]]
    [data
diff --git a/stdlib/source/test/lux/host.jvm.lux b/stdlib/source/test/lux/host.jvm.lux
index 9bd0f5399..04c149881 100644
--- a/stdlib/source/test/lux/host.jvm.lux
+++ b/stdlib/source/test/lux/host.jvm.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
+   [abstract/monad (#+ Monad do)]
    [control
-    [monad (#+ Monad do)]
     pipe]
    [data
     ["." text ("#;." equivalence)]]
diff --git a/stdlib/source/test/lux/host/jvm.jvm.lux b/stdlib/source/test/lux/host/jvm.jvm.lux
index b0655ebd3..16c4aea90 100644
--- a/stdlib/source/test/lux/host/jvm.jvm.lux
+++ b/stdlib/source/test/lux/host/jvm.jvm.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
+   [abstract/monad (#+ do)]
    [control
-    [monad (#+ do)]
     [concurrency
      ["." atom]]
     [security
diff --git a/stdlib/source/test/lux/io.lux b/stdlib/source/test/lux/io.lux
index 504c9bb9c..3b00ceb3f 100644
--- a/stdlib/source/test/lux/io.lux
+++ b/stdlib/source/test/lux/io.lux
@@ -3,7 +3,7 @@
    data/text/format
    ["_" test (#+ Test)]
    ["r" math/random]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/macro.lux b/stdlib/source/test/lux/macro.lux
index d7389dd20..acd4bcdac 100644
--- a/stdlib/source/test/lux/macro.lux
+++ b/stdlib/source/test/lux/macro.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    data/text/format
-   [control/monad (#+ do)]
+   [abstract/monad (#+ do)]
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]]
   {1
diff --git a/stdlib/source/test/lux/macro/code.lux b/stdlib/source/test/lux/macro/code.lux
index c400bf206..c8d0b8077 100644
--- a/stdlib/source/test/lux/macro/code.lux
+++ b/stdlib/source/test/lux/macro/code.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    data/text/format
-   [control/monad (#+ do)]
+   [abstract/monad (#+ do)]
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
    [data
diff --git a/stdlib/source/test/lux/macro/poly/equivalence.lux b/stdlib/source/test/lux/macro/poly/equivalence.lux
index 41ae1ecd0..4024d0a89 100644
--- a/stdlib/source/test/lux/macro/poly/equivalence.lux
+++ b/stdlib/source/test/lux/macro/poly/equivalence.lux
@@ -3,8 +3,8 @@
    data/text/format
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
-   [control ["." monad (#+ do)]]
-   [control
+   [abstract/monad (#+ do)]
+   [abstract
     [equivalence (#+ Equivalence)]]
    [data
     ["." bit]
diff --git a/stdlib/source/test/lux/macro/poly/functor.lux b/stdlib/source/test/lux/macro/poly/functor.lux
index 5b477682d..7f47148ab 100644
--- a/stdlib/source/test/lux/macro/poly/functor.lux
+++ b/stdlib/source/test/lux/macro/poly/functor.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    data/text/format
-   [control/monad (#+ do)]
+   [abstract/monad (#+ do)]
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
    [control
diff --git a/stdlib/source/test/lux/macro/poly/json.lux b/stdlib/source/test/lux/macro/poly/json.lux
index 2669b9801..1209aa90a 100644
--- a/stdlib/source/test/lux/macro/poly/json.lux
+++ b/stdlib/source/test/lux/macro/poly/json.lux
@@ -2,16 +2,17 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
-    pipe
+   [abstract
     codec
     [monad (#+ do Monad)]
     [equivalence (#+ Equivalence)]
-    ["p" parser]
     {[0 #test]
      [/
       ["$." equivalence]
       ["$." codec]]}]
+   [control
+    pipe
+    ["p" parser]]
    [data
     ["." error]
     ["." bit]
diff --git a/stdlib/source/test/lux/macro/syntax.lux b/stdlib/source/test/lux/macro/syntax.lux
index 60dd38b6e..92ba86d4d 100644
--- a/stdlib/source/test/lux/macro/syntax.lux
+++ b/stdlib/source/test/lux/macro/syntax.lux
@@ -1,11 +1,12 @@
 (.module:
   [lux #*
    data/text/format
-   [control/monad (#+ do)]
+   [abstract/monad (#+ do)]
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
+   [abstract
+    [equivalence (#+ Equivalence)]]
    [control
-    [equivalence (#+ Equivalence)]
     ["p" parser]]
    [data
     ["." bit]
diff --git a/stdlib/source/test/lux/math.lux b/stdlib/source/test/lux/math.lux
index a659e8095..fcd4a1134 100644
--- a/stdlib/source/test/lux/math.lux
+++ b/stdlib/source/test/lux/math.lux
@@ -3,8 +3,7 @@
    data/text/format
    ["_" test (#+ Test)]
    ["r" math/random (#+ Random)]
-   [control
-    [monad (#+ Monad do)]]
+   [abstract/monad (#+ Monad do)]
    [data
     ["." bit ("#@." equivalence)]
     [number
diff --git a/stdlib/source/test/lux/math/infix.lux b/stdlib/source/test/lux/math/infix.lux
index 59a44022a..db40f693c 100644
--- a/stdlib/source/test/lux/math/infix.lux
+++ b/stdlib/source/test/lux/math/infix.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    data/text/format
-   [control/monad (#+ do)]
+   [abstract/monad (#+ do)]
    ["r" math/random]
    ["_" test (#+ Test)]
    [data
diff --git a/stdlib/source/test/lux/math/logic/continuous.lux b/stdlib/source/test/lux/math/logic/continuous.lux
index 214a3c041..82ad36be0 100644
--- a/stdlib/source/test/lux/math/logic/continuous.lux
+++ b/stdlib/source/test/lux/math/logic/continuous.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    data/text/format
-   [control/monad (#+ do)]
+   [abstract/monad (#+ do)]
    ["r" math/random]
    ["_" test (#+ Test)]]
   {1
diff --git a/stdlib/source/test/lux/math/logic/fuzzy.lux b/stdlib/source/test/lux/math/logic/fuzzy.lux
index e75268bf0..10b75195a 100644
--- a/stdlib/source/test/lux/math/logic/fuzzy.lux
+++ b/stdlib/source/test/lux/math/logic/fuzzy.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux #*
    data/text/format
-   [control/monad (#+ do)]
+   [abstract/monad (#+ do)]
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
    [data
diff --git a/stdlib/source/test/lux/math/modular.lux b/stdlib/source/test/lux/math/modular.lux
index 97655ee9b..5d929527e 100644
--- a/stdlib/source/test/lux/math/modular.lux
+++ b/stdlib/source/test/lux/math/modular.lux
@@ -3,7 +3,7 @@
    data/text/format
    ["_" test (#+ Test)]
    ["r" math/random]
-   [control/monad (#+ do)]
+   [abstract/monad (#+ do)]
    [data
     ["." product]
     ["." bit ("#@." equivalence)]
diff --git a/stdlib/source/test/lux/time/date.lux b/stdlib/source/test/lux/time/date.lux
index ffd055e35..483b51388 100644
--- a/stdlib/source/test/lux/time/date.lux
+++ b/stdlib/source/test/lux/time/date.lux
@@ -3,7 +3,8 @@
    data/text/format
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
-   [control ["." monad (#+ do)]
+   [abstract
+    ["." monad (#+ do)]
     {[0 #test]
      [/
       ["$." equivalence]
diff --git a/stdlib/source/test/lux/time/day.lux b/stdlib/source/test/lux/time/day.lux
index 84d404a21..4df0ad30b 100644
--- a/stdlib/source/test/lux/time/day.lux
+++ b/stdlib/source/test/lux/time/day.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     {[0 #test]
      [/
       ["$." equivalence]
diff --git a/stdlib/source/test/lux/time/duration.lux b/stdlib/source/test/lux/time/duration.lux
index a7265f62f..e63397b32 100644
--- a/stdlib/source/test/lux/time/duration.lux
+++ b/stdlib/source/test/lux/time/duration.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad (#+ do)]
     {[0 #test]
      [/
diff --git a/stdlib/source/test/lux/time/instant.lux b/stdlib/source/test/lux/time/instant.lux
index 9b903d993..24f7e7962 100644
--- a/stdlib/source/test/lux/time/instant.lux
+++ b/stdlib/source/test/lux/time/instant.lux
@@ -2,8 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
-    pipe
+   [abstract
     [monad (#+ do Monad)]
     {[0 #test]
      [/
@@ -11,6 +10,8 @@
       ["$." order]
       ["$." enum]
       ["$." codec]]}]
+   [control
+    pipe]
    [data
     ["." text]]
    [math
diff --git a/stdlib/source/test/lux/time/month.lux b/stdlib/source/test/lux/time/month.lux
index f0722af0b..7b0cb43d2 100644
--- a/stdlib/source/test/lux/time/month.lux
+++ b/stdlib/source/test/lux/time/month.lux
@@ -2,7 +2,7 @@
   [lux #*
    data/text/format
    ["_" test (#+ Test)]
-   [control
+   [abstract
     {[0 #test]
      [/
       ["$." equivalence]
diff --git a/stdlib/source/test/lux/type.lux b/stdlib/source/test/lux/type.lux
index 96478b077..6840807f7 100644
--- a/stdlib/source/test/lux/type.lux
+++ b/stdlib/source/test/lux/type.lux
@@ -1,7 +1,7 @@
 (.module:
   [lux (#- type)
    data/text/format
-   ["M" control/monad (#+ do)]
+   ["M" abstract/monad (#+ do)]
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
    [control
diff --git a/stdlib/source/test/lux/type/check.lux b/stdlib/source/test/lux/type/check.lux
index d73b2783d..9d511d5ae 100644
--- a/stdlib/source/test/lux/type/check.lux
+++ b/stdlib/source/test/lux/type/check.lux
@@ -1,9 +1,10 @@
 (.module:
   [lux (#- type)
    data/text/format
-   [control ["." monad (#+ do)]]
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
+   [abstract
+    ["." monad (#+ do)]]
    [control
     [pipe (#+ case>)]]
    [data
diff --git a/stdlib/source/test/lux/type/dynamic.lux b/stdlib/source/test/lux/type/dynamic.lux
index e2564627a..4e1bea6a8 100644
--- a/stdlib/source/test/lux/type/dynamic.lux
+++ b/stdlib/source/test/lux/type/dynamic.lux
@@ -1,9 +1,9 @@
 (.module:
   [lux #*
    data/text/format
+   [abstract/monad (#+ do)]
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
-   [control ["." monad (#+ do)]]
    [data
     ["." error]]]
   {1
diff --git a/stdlib/source/test/lux/type/implicit.lux b/stdlib/source/test/lux/type/implicit.lux
index 5383c252f..372f544f7 100644
--- a/stdlib/source/test/lux/type/implicit.lux
+++ b/stdlib/source/test/lux/type/implicit.lux
@@ -3,8 +3,8 @@
    data/text/format
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
-   [control ["." monad (#+ do)]]
-   [control
+   [abstract/monad (#+ do)]
+   [abstract
     [equivalence (#+)]
     [functor (#+)]]
    [data
diff --git a/stdlib/source/test/lux/type/resource.lux b/stdlib/source/test/lux/type/resource.lux
index 15d7cd137..293629e18 100644
--- a/stdlib/source/test/lux/type/resource.lux
+++ b/stdlib/source/test/lux/type/resource.lux
@@ -3,7 +3,7 @@
    data/text/format
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
-   [control
+   [abstract
     [monad
      [indexed (#+ do)]]]
    ["." io]]
diff --git a/stdlib/source/test/lux/world/binary.lux b/stdlib/source/test/lux/world/binary.lux
index 2e463ea4b..a9817115d 100644
--- a/stdlib/source/test/lux/world/binary.lux
+++ b/stdlib/source/test/lux/world/binary.lux
@@ -3,7 +3,8 @@
    data/text/format
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
-   [control ["." monad (#+ do)]
+   [abstract
+    ["." monad (#+ do)]
     {[0 #test]
      [/
       ["$." equivalence]]}]
diff --git a/stdlib/source/test/lux/world/file.lux b/stdlib/source/test/lux/world/file.lux
index e27add632..86b031660 100644
--- a/stdlib/source/test/lux/world/file.lux
+++ b/stdlib/source/test/lux/world/file.lux
@@ -3,8 +3,8 @@
    data/text/format
    ["r" math/random (#+ Random) ("#@." monad)]
    ["_" test (#+ Test)]
+   [abstract/monad (#+ do)]
    [control
-    ["." monad (#+ do)]
     [concurrency
      ["." promise]]
     [security
diff --git a/stdlib/source/test/lux/world/net/tcp.lux b/stdlib/source/test/lux/world/net/tcp.lux
index f7ec2eaef..b3f9a6d0d 100644
--- a/stdlib/source/test/lux/world/net/tcp.lux
+++ b/stdlib/source/test/lux/world/net/tcp.lux
@@ -3,7 +3,7 @@
    data/text/format
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
-   [control ["." monad (#+ do)]]
+   ["." abstract/monad (#+ do)]
    ["." io (#+ IO)]
    [control
     ["ex" exception (#+ exception:)]
diff --git a/stdlib/source/test/lux/world/net/udp.lux b/stdlib/source/test/lux/world/net/udp.lux
index 1740c861c..2e61257ad 100644
--- a/stdlib/source/test/lux/world/net/udp.lux
+++ b/stdlib/source/test/lux/world/net/udp.lux
@@ -3,8 +3,8 @@
    data/text/format
    ["r" math/random (#+ Random)]
    ["_" test (#+ Test)]
+   ["." abstract/monad (#+ do)]
    [control
-    ["." monad (#+ do)]
     [concurrency
      ["." promise]]
     [security
-- 
cgit v1.2.3