…is a template metaprogramming library intended for compile time computation written in C++. As its name implies it follows the overall concept of viewing types as values and templates as functions manipulating those values.

This library is a expanded reimplementation of my previous attempt at this problem: ConstList. As detailed in the appropriate blog article the mixed approach between generic lambda expressions, constexpr marked functions and template metaprogramming doesn't offer sufficient flexibility which led me to approach compile time computation in a slightly different manner via this new library. As one might notice this boils down to using Scheme as a metaphor for C++ template metaprogramming. In fact all test cases and examples are documented by representing their logic in Scheme.

Furthermore an overview of this library alongside some background information is available in the form of a blog article on using Scheme as a metaphor for template metaprogramming.


// λ (length (filter odd? (list 1 2 3)))
// 2

const std::size_t count = tav::Length<
        tav::List<tav::Int<1>, tav::Int<2>, tav::Int<3>>

More extensive examples are available in the form of implementations of the Sieve of Eratosthenes as well as of a Turing machine.

Current features

  • guaranteed evaluation during compile time
  • basic math and logic operations
  • conditionals such as If and Cond
  • Cons constructor for Pair type
  • List function as helper for Pair based list construction
  • basic list operators such as Nth, Length, Take and Append
  • list generators such as Iota and MakeList
  • higher order list operation Fold
  • higher order list operations such as Map and Filter expressed in terms of Fold
  • higher order list queries such as Find, Any, All and None
  • higher order list generators such as ListTabulate
  • higher order list operations such as TakeWhile, Partition and Sort
  • basic partial function application support using Apply
  • static_assert based test cases for all of the above
  • MIT license


As TypeAsValue is completely implemented via template metaprogramming it is a header only library and as such may only be built in conjunction with the code which is making use of it. This means that one may use a arbitrary build system in practice while the static_assert based test cases and example applications make use of CMake and can be compiled as follows:

git clone "https://github.com/KnairdA/TypeAsValue.git"
cd TypeAsValue # respectively "cd TypeAsValue/example/{turing|prime}"
mkdir build
cd build
cmake ..


  • C++ compiler with support for C++14
  • CMake for building test cases