* there is no reason to differ from the rest of the library and use inheritance in this instance
* added link to blog article on the _Scheme metaphor_ to `README.md`

* usage of `Apply` sans placeholders was already possible and as such duplicated `utility::defer_eval`
* renamed `apply_none`'s type alias from to `type` to enable combining it with `Eval`

* separate actual `Apply` specializations in `detail/apply.h` from placeholder details

* pure _syntax sugar_ to improve readability of `Cond` conditionals

* `detail::generate_nested_structure` offers a higher order nested structure constructor for procedural list generation
* renamed `Fold` implementation details

* continuation of 8e49cc6
* list constructor was generalized to a _variadic fold_

* while class templates enable e.g. hiding implementation details they also require evaluation via `Eval`
** this clutters up the actual logic and is now hidden behind aliae that perform the evaluation

* replaces `typename *::type` constructs with `Eval` applications
* aims to further unify function evaluation

* `type` is used to represent evaluation of a template
* accessing the `function` doesn't evaluate it as it is the template itself

* returns the `CDR` of the first true `CAR` in a given list of pairs
* reimplemented `Apply` base class selection in terms of `Cond`

* moved internals into separate header i.e. the `detail` namespace relating to `Apply`
* implemented automatic alias selection by implementing aliae of the basic variadic `type` template alias in different base classes
** variadic partial application is implemented in `detail::apply_variadic`
*** `detail::apply_single` and `detail::apply_pair` define aliae to `detail::apply_variadic`'s `type` template alias
*** both restricted aliae derive from `detail::apply_variadic`
** `Apply` derives from any of the aliae defining base classes depending on the count of placeholders as determined by `detail::count_placeholders`
*** `Apply` is guaranteed to always be derived from `detail::apply_variadic` one way or the other
* changed functions, test cases and examples depending on `Apply` accordingly
** `Length` had to be reimplemented without `Apply` as it doesn't allow usage of aliae expecting a different count of arguments anymore
*** this is a advantage in the sense that core functionality of _TypeAsValue_ now doesn't depend on this complex partial application implementation anymore
*** such functionality may be reimplemented separately from `Apply`
* removed unnecessary `tav` namespace prefixes

* this function illustrates the use case `Apply` is currently intended for
* moved `Take` and `Nth` into separate files to resolve header resolution conflicts

* function `Apply` enables partial supply of the template parameters of a given _function_
** unsupplied parameters may be marked by _placeholders_, i.e. approach is similar to `std::bind`
** returns a template type taking the remaining, unsupplied parameters of the partially applied _function_
* this is a prototype in the sense, that neither full application using `Apply` or partial application of higher order functions is currently supported
** e.g. a `single_type` alias type declaration is required as the variadic template `template<typename...>` doesn't directly map to `template<typename>`
* appropriate test cases document current feature set
* the goal is to enable a concise defintion of _lambda-like_ expressions for easy specialization of e.g. functors provided to higher order functions