Remove replication.

Remove replication on declare operations for now, until we are able to
get the CRDT functionality completed.
Add riak_dt dependency.
Allow type during declare.

Allow users to specify a type when declaring a variable.  If working
with a stream, this type persists for all items in the stream.
Prototype inflation re-bind.

Allow a variable to be re-bound if it's a datatype that's build on top
of a join-semilattice and we can determine the change is an inflation of
the lattice.
Ignore the log.
Add prototype test over lattices.

Compose a series of lattices via streams; ensure that replay and
ordering doesn't matter for convergence.
Rename put to write.

This prevents an interaction that prevents us from calling the functions
which allow us to interact with the process dictionary.
Add lager_transform.

Ensure that when we remotely compile a file we use the lager transform
to allow logging to succeed.
Ensure we distribute computations.

Make the thread operation run on a remote node based on MFA; this allows
us to distribute computations across the cluster.
Rename table to variables.

Distinquish which table we are storing variables in, given we may have
to open a new ETS table in the future for additional information.
Convert to lager calls.
Convert examples to use thread.
Track spawns.

Every time we launch a process, use the process dictionary to store
information about the exact caller; we can't use the process_info/1
command because it doesn't track the calling args.
Track read.

When a read request happens, track the calling function through the use
of the process dictionary.
Track readers.

Every time a read is performed, track the calling MFA, so we are able to
know which completed functions should be re-executed if the state of the
lattice changes.
Ignore earlier lattice states.

If we attempt to bind a lattice with a value we've already progressed
past, ignore it, but don't return an error.  This is semantically
equivalent to allowing rebinds of the same value in the single
assignment store.
Consume isn't tracked.

Don't count calls to consume on a stream as a read call, thereby
dirtying the re-execution chain.  This is problematic as we're not sure
what the semantics on reading a stream of lattices is.

For example, given a stream of G-Sets.  If the first G-set is consumed,
and a LWW-register is updated as a result, when we consume the second
G-set, do we re-evaluate the entire stream again, as the second write to
the LWW-register causes the original write to be marked for
re-execution.

For now, only explicit reads of values are tracked.
Add additional logging.
Inflations are only increases.

Technically, an inflation is the same value (I think?), however, for the
purposes of updating the ETS backend, and from preventing circular
dependencies between executing processes, only modify the value if
necessary.
Whitespace adjustment.