   console.log.apply null, splat if splat.length
   process.exit 1
 say = (splat...) -> console.log.apply null, splat
+
+# ### Collation
+#
+# A b-tree has a client defined collation. The collation is determined by the
+# combination of an extractor and a comparator. The extractor is used to
+# extract or calculate from the stored record the fields values pertient to the
+# collation. The comparator is used to order records by comparing the extracted
+# fields.
+#
+# The extractor allows us to cache the fields pertinent to the collation. It may
+# be the case that records have large fields that are not pertinent to the
+# collation. If we are only using the record as a point of reference while
+# searchng the tree, we allow the record to fall out of the cache, and hold onto
+# only the pertient fields. 
+#
+# This strategy wouldn't work if extraction and comparison were the same
+# function. By making them separate functions, we can cache the intermediate
+# extraction step.
+#
+# Additionally, the comparitor is pretty easily generalized, while the exractor
+# is invariably specialized.
 
 # Default comparator is good only for strings, use a - b for numbers.
 comparator = (a, b) ->

      true
    false

# ### Leaf Tier Files
#
# A leaf tier maintains an array of file positions called an address array. A

    fs.close(@fd, _) if @fd
    @position = @fd = null

# ### Tier File Storage
#
# Tiers are identified by a number tier address. The tier address is a number
# that is incremented as new tier are created. A branch tier file has a file
# name that includes the tier address. The file name is derived from the tier
# address. When we load a tier, we first derive the file name from the tier
# address, then we load the file.
#
# The leaf tier file contains insert objects, delete objects and address array
# objects, stored as JSON, one object per line, as described above.
#
# The branch tier file contains a single object that includes the array of
# tier addresses. The tier addresses reference leaf tier files. The tier
# addresses are sorted according to the value of the objects in leaf tiers they
# reference. The addresses are sorted by the tree collation using the record
# from the referenced leaf tier that has the least value according to the tree
# collation.
#
# Put another way, each branch element in a branch tier represents a leaf tier.
# The leaf tiers are sorted by the tree collation. The object value used to sort
# the branch tier is first element in the sorted leaf tier.
#
# TODO Okay, what? I'm forgetting that I need the addresses to inner tiers as
# well as to leaf tiers, both, when the tier is not penultimate. Descending is
# not going to work, that is going to load the entire tree into memory quickly.
#
# Hmm... Maybe not. Tree four deep means loading only a particular path. It
# ensures that we read lock our way down the tree to get our record. Although, I
# believe I thought long and hard about this, and jumping down to the leaves
# wasn't a problem.
#
# We only need to store the sorted array of the leaf tier addresses in our
# branch tier, since we can obtain the object used to collate the address

#
class IO
