The odreex::ample::storage_sequential as a typelist base.

We have implemented storage_block and operations for it in the form of class
templates like storage_push_back, storage_push_front, storage_pop_front,
storage_pop_back, storage_pop_tail_by, storage_pop_head_by. In order to
complete basic container operations for type containers with sequential
access semantics, we need to implement random access retrieval and
alteration. This can be done in any number of ways, but most of all it has
to consider the fact that at any given point pushing and popping types
out of either left / right "bounds" of the type container is possible.

Pushing and popping "types" all around efficiently and correctly requires
in the end having two separate storage_block class templates instantiated,
where head / tail operations end up taking place. The "simpler" alternative
would require re - iterating through all types contained every time any kind
of operation (including random access alteration) takes place, which would
greately add to compilation times and reduce flexibility by making several
of these operations O(n), O(n^2) or worse, despite that seems the "obvious"
way to do things with C++11 template variadics.

The solution to random access retrieval is common with the one for random
access alteration, provided we know which of the two blocks making up the
actual type container (i.e. storage_sequential - based one) contains the item
that interests us, therefore the search for that item is to be adjusted
between the elements of the "left" and "right" storage_block in the
storage_sequential class template.

All that remains then, is having a way to instantiate a storage_sequential
class template correctly so that everything sticks together the way it should
and that is what the storage_pack template is all about, "packing" the types
through storage_push_front, storage_push_back to the correct storage_block
types of which storage_sequential is comprised of.