| Age | Commit message (Collapse) | Author |
|---|
|
|
|
* 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
|
|
|
|
|
|
|
|
* as everything this library does happens during compile time it can be checked using standard language features
** i.e. `static_assert` already offers everything needed for test cases in this situation
|
|
* it may be useful for more than test cases
|
|
* as its name implies this _function_ only returns elements which evaluate to _true_ when passed to a given _function_
** this marks the moment where _TypeAsValue_ supports something _ConstList_ does not, i.e. primary goal is achieved
*** namely returning different types depending on the actual _values_ of a _Cons_ structure
* added appropriate test case
|
|
|
|
* as its name implies this _function_ applies a given _function_ to each element of a _Cons_ structure
* added appropriate test case
|
|
* this removes the need for maintaining a partial overload of `Length`
* the recursive traversion of the _Cons_ structure is now implemented by `Fold` instead of needlessly duplicating it
|
|
* applies a given _function_ to each _Cons_ starting with a initial value
* added appropriate test case
|
|
* partial specializations offer control over lazy type instantiation
** `If` is currently only a `std::conditional` wrapper and requires further refinement to be really useful for this kind of use case
|
|
* as its name implies this function _takes_ a maximum of _Count_ elements of a list
* added appropriate test case
|
|
* as its name implies this function returns the _nth_ value of a given _Cons_ structure
* added appropriate test case
|
|
|
|
* as its name implies this function returns the length of a given _Cons_ structure
* result type is `Size<Length>` which wraps `std::size_t` to match the `sizeof` operator
|
|
|
|
* concatenates two given _Cons_ based lists into a single one
|
|
* `Cons` is a straigth forward type _pair_ containing `car` and `cdr` typedefs
** they may be accessed using `Car` and `Cdr` helper template aliases
** there is no enforcement of _Cons_ structure and type equality whatsoever
*** i.e. similar to Scheme and different from how it is implemented in _ConstList_
* `List` is a recursive variadic helper template for constructing `Cons` value types
** simplifies _Cons_ construction and may be expanded to offer type deduction and built upon to enforce type equality
* added appropriate test cases
|
|
|
|
|
|
|
|
|
|
|
