Nomenclature
============

In this documentation, functions are labled with
some keywords to note common behaviors.

 - "chainable" means that the function takes an object
   and returns the object or a copy of the object
   so that function calls can be chained from output
   to input like a pipeline.  There are stateful
   and stateless variants of chainability.

 - "stateful" means that a function modifies an
   object's state.  Stateful functions often return
   the provided and subsequently modified object.
   Stateful functions have present tense verbs for
   names like ``sort``, and ``add``.

 - "stateless" means that a function does not modify
   the given object.  Stateless functions have no
   side-effects on the object they're called on.
   Stateless member functions
   often have verbs in perfect past tense for names,
   like ``sorted`` and ``added``.  They usually
   correspond to a module-scope stateless function
   with a present tense verb name like ``sort``
   or ``add``.  Many stateless functions differ
   from a stateful counterpart in that they return a
   modified copy of the given object.

 - "polymorphic" means that a module-scope function
   provides default behaviors for all meaningful
   native types, like ``Object``, ``Array``,
   ``Date`` and ``String``, but always defers
   to a member function, usually having the same
   name, of a user-defined Chiron type.  For example,
   if you call ``add`` with a Chiron ``Dict``,
   ``add`` will defer to the dictionary's 
   ``added`` member function.

 - "curries" means that a function, if provided
   fewer arguments than it needs to complete an operation,
   will return a new function that you can repeatedly
   use to perform that operation on various
   objects.  The curried function always accepts
   one object as its argument and will polymorphically
   apply the operation with the other arguments.  For
   example, ``set("a", 10)`` returns a function that
   can set the value 10 for the key "a" on an
   ``Object``, ``Dict``, or any other type that provides
   a ``set`` member function.

 - "idempotent" means that a function always
   returns the same result for if results are passed
   back into the function.

   ``idempotent(idempotent(input)) == idempotent(input)``

 - a "relation" is a function that maps a single
   argument in some domain to a return result
   in some range.  The functions curried by
   ``get`` are relations.  Type conversion
   functions are relations that restrict the
   type of the elements in the range.
   All iterables, particularly
   dictionaries, are relations that map
   keys to values.  Relations are useful for
   transforming iterations with ``each`` and
   ``map``, for creating comparators for
   ``sort`` using ``by``, and for creating 
   a dictionary of equivalence classes (sets) using 
   ``group``.

 - a "boolean relation" is a
   relation that returns "true" or "false".
   That is, it maps all of its domain into
   the boolean range.  "predicates" are
   boolean relations.

 - an "identity relation" is a relation that
   maps all of the elements of its domain
   directly into its range.  That is, it always
   returns the value you pass it.  The function named
   ``pass`` is an identity relation.

 - a "contract" is an identity relation that
   throws an exception if a value returns false
   for some given boolean relation, albeit
   a predicate.

 - a "comparator" is a function that accepts
   to values and returns an integer that represents
   whether the first argument is greater, equal to,
   or less than the second argument.

   ``compare(a, b) == compare(compare(a, b), 0)``