Age | Commit message (Collapse) | Author |
|
* 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`
|
|
* analogously to `IsPair`
|
|
* 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
|
|
* as it is commonly required functionality and as such should be provided by this library
|
|
|
|
* added further test cases for `Sort` as well as `Nth` aliae
|
|
* increases expressiveness in some contexts
* renamed `Partition` list template parameter to avoid confusion
|
|
* otherwise a type conflict occurs when trying to instantiate a list of `void`
** this hinders construction of higher level functionality on top of `List`
|
|
* _Quicksort_ is the algorithm of choice
** it lends itself quite well to the _TypeAsValue_ approach because of its recursive nature
** this required implementation of a `Drop` counterpart to `Take`
* the middle item of a given list is selected as the _pivot_ element
* the `List` list contructor had to be expanded to allow `void` arguments inside its variadic parameter pack
* added appropriate test cases
|
|
|
|
|
|
|
|
* this is analogous to _Scheme_ where a pair (dot-expression) is returned from a call to `cons`
* `Head` and `Tail` are kept as direct references to the `CAR` and `CDR` values of a pair to match e.g. the math operators
|
|
* all other functions sans `Cons` are resolved when the respective member `*::type` is instantiated
* this was changed soely to increase coherence
|
|
* both depict the very usecase partial function application via `Apply` is suited for
|
|
|
|
|
|
* i.e. we probably will want to access our compile time computed values at runtime sooner or later
* runtime iteration using e.g. a normal _for-loop_ is not possible as we obviously can't dynamically insert new types into our templates
|
|
* analogously to how `Contains` is implemented as a wrapper around `Any`
* added appropriate test case and lessened restrictions on `Contains`'s comparator
|
|
|
|
|
|
|
|
* as its name implies this function returns the longest initial prefix of a list that satisfies a given _Predicate_
* added appropriate test case
|
|
* added appropriate test case
* other queries in `query.h` may be redefined in terms of `Find`
|
|
* `Remove` is a basic `Filter` alias that negates its predicate
* `Partition` builds on both `Remove` and `Filter` to return both the elements satisfying a predicate and those which don't
|
|
* there is no reason to keep them in the same header
|
|
* enables construction of `Cons` structures using the same value type across all their elements
|
|
* 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
|
|
* as its name implies this function counts the amount of elements satisfying a given _function_
* added appropriate test case
|
|
* redefined `Even` in terms of `Modulo` and removed unnecessary dependent name declarators
* added appropriate test case, also for `Square`
|
|
* as its name implies this function returns a list of `Count` elements of value `Element`
* added appropriate test case
|
|
* added `Square` function to math operations header to facilitate a simple test case
* added appropriate test case
|
|
* recursively generates a list of `Count` elements starting at `Initial` and consecutively adding `Step`
** as most functionality of this library this function was modeled after its _Scheme_ equivalent `iota`
** it may be used as the foundation of a set of higher order list generators including e.g. `list-tabulate`
* added appropriate test cases
|
|
|
|
* added appropriate test case
|
|
|
|
* as its name implies this _function_ simplifies checking if a specific value is contained within a given list
* updated `Map` to actually resolve the provided _function_
|
|
* it is not in itself a higher order function but only based on one
|
|
|
|
|
|
* in terms of `Fold` and `Map`, not the most efficient but reasonably concise
* added appropriate test cases
|
|
|
|
|
|
|