Type List

Provides bio::meta::type_list and metaprogramming utilities for working on type lists. More...

Collaboration diagram for Type List:

Classes
struct	bio::meta::type_list< types >
	Type that contains multiple types. More...

Type list traits (return a single type)
template<ptrdiff_t idx, typename list_t >
using	bio::meta::list_traits::at = typename decltype(detail::at< idx >(list_t{}))::type
	Return the type at given index from the type list.
template<typename list_t >
using	bio::meta::list_traits::front = typename decltype(detail::front(list_t{}))::type
	Return the first type from the type list.
template<typename list_t >
using	bio::meta::list_traits::back = typename decltype(detail::back(list_t{}))::type
	Return the last type from the type list.

Type list traits (return a type list)
template<typename... lists_t>
using	bio::meta::list_traits::concat = decltype(detail::concat(lists_t{}...))
	Join two meta::type_list s into one.
template<typename list_t >
using	bio::meta::list_traits::drop_front = decltype(detail::drop_front(list_t{}))
	Return a meta::type_list of all the types in the type list, except the first.
template<ptrdiff_t i, typename list_t >
using	bio::meta::list_traits::take = typename decltype(detail::split_after< i >(list_t{}))::first_type
	Return a meta::type_list of the first n types in the input type list.
template<ptrdiff_t i, typename list_t >
using	bio::meta::list_traits::drop = typename decltype(detail::split_after< i >(list_t{}))::second_type
	Return a meta::type_list of the types in the input type list, except the first n.
template<ptrdiff_t i, typename list_t >
using	bio::meta::list_traits::take_last = drop< size< list_t > - i, list_t >
	Return a meta::type_list of the last n types in the input type list.
template<ptrdiff_t i, typename list_t >
using	bio::meta::list_traits::drop_last = take< size< list_t > - i, list_t >
	Return a meta::type_list of the types the input type list, except the last n.
template<ptrdiff_t i, typename list_t >
using	bio::meta::list_traits::split_after = decltype(detail::split_after< i >(list_t{}))
	Split a meta::type_list into two parts returned as a pair of meta::type_list.
template<template< typename > typename trait_t, typename list_t >
using	bio::meta::list_traits::transform = decltype(detail::transform< trait_t >(list_t{}))
	Apply a transformation trait to every type in the list and return a meta::type_list of the results.
template<typename replace_t , std::ptrdiff_t i, typename list_t >
using	bio::meta::list_traits::replace_at = decltype(detail::replace_at< replace_t, i >(list_t{}))
	Replace the type at the given index with the given type.
template<size_t count, typename t >
using	bio::meta::list_traits::repeat = decltype(detail::repeat< count, t >())
	Create a type list with the given type repeated count times..

Type list traits (return a value)
template<typename... pack_t>
constexpr size_t	bio::meta::list_traits::size< type_list< pack_t... > > = sizeof...(pack_t)
	The size of a type list.
template<typename query_t , typename... pack_t>
constexpr ptrdiff_t	bio::meta::list_traits::count< query_t, type_list< pack_t... > > = meta::detail::pack_traits::count<query_t, pack_t...>
	Count the occurrences of a type in a type list.
template<typename query_t , typename... pack_t>
constexpr ptrdiff_t	bio::meta::list_traits::find< query_t, type_list< pack_t... > >
	Get the index of the first occurrence of a type in a type list.
template<template< typename > typename pred_t, typename... pack_t>
constexpr ptrdiff_t	bio::meta::list_traits::find_if< pred_t, type_list< pack_t... > >
	Get the index of the first type in a type list that satisfies the given predicate.
template<typename query_t , typename list_t >
constexpr bool	bio::meta::list_traits::contains = (find<query_t, list_t> != -1)
	Whether a type occurs in a type list or not.

Detailed Description

Provides bio::meta::type_list and metaprogramming utilities for working on type lists.

All traits on type lists are defined in the header <bio/meta/type_list/traits.hpp>.

Typedef Documentation

at

template<ptrdiff_t idx, typename list_t >

using bio::meta::list_traits::at = typedef typename decltype(detail::at<idx>(list_t{}))::type

Return the type at given index from the type list.

Template Parameters

idx	The index; must be smaller than the size of the type list.
list_t	The type_list.

Negative indexes are supported (e.g. at<-1, type_list<int, double, bool &>> is bool &).

(Compile-time) Complexity

• Number of template instantiations: O(n)
• Other operations: O(n)

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, double>;
 
    // Look at the 2nd element.
    static_assert(std::same_as<float, bio::meta::list_traits::at<1, list_t>>);
    // Look at the last element.
    static_assert(std::same_as<double, bio::meta::list_traits::at<-1, list_t>>);
}

back

template<typename list_t >

using bio::meta::list_traits::back = typedef typename decltype(detail::back(list_t{}))::type

Return the last type from the type list.

Template Parameters

list_t

The type list.

(Compile-time) Complexity

• Number of template instantiations: O(n) (possibly O(1))
• Other operations: O(1)

Notably faster than meta::detail::pack_traits::at<size<pack...> - 1, pack...> (no recursive template instantiations).

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, int, float>;
 
    // Access the last value (float) with bio::meta::list_traits::back
    static_assert(std::same_as<float, bio::meta::list_traits::back<list_t>>);
}

concat

template<typename... lists_t>

using bio::meta::list_traits::concat = typedef decltype(detail::concat(lists_t{}...))

Join two meta::type_list s into one.

Template Parameters

list1_t	The first (input) type list.
list2_t	The second (input) type list.

(Compile-time) Complexity

• Number of template instantiations: O(n) in the number of type lists
• Other operations: O(n) in the number of type lists

Complexity is independent of the number of types in each list.

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool>;
    using list_t2 = bio::meta::type_list<double, char, int>;
    using list_t3 = bio::meta::type_list<int, int>;
 
    static_assert(std::same_as<bio::meta::list_traits::concat<list_t, list_t2, list_t3>,
                               bio::meta::type_list<int, float, bool, double, char, int, int, int>>);
}

drop

template<ptrdiff_t i, typename list_t >

using bio::meta::list_traits::drop = typedef typename decltype(detail::split_after<i>(list_t{}))::second_type

Return a meta::type_list of the types in the input type list, except the first n.

Template Parameters

i	The amount to drop; must be >= 0 and <= the size of the input type list.
list_t	The (input) type list.

(Compile-time) Complexity

• Number of template instantiations: O(n)
• Other operations: O(n)

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, int>;
 
    // Drop the first two types in list_t.
    static_assert(std::same_as<bio::meta::type_list<bool, int>, bio::meta::list_traits::drop<2, list_t>>);
}

drop_front

template<typename list_t >

using bio::meta::list_traits::drop_front = typedef decltype(detail::drop_front(list_t{}))

Return a meta::type_list of all the types in the type list, except the first.

Template Parameters

list_t

The (input) type list.

(Compile-time) Complexity

• Number of template instantiations: O(1)
• Other operations: O(1)

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, int>;
 
    static_assert(std::same_as<bio::meta::type_list<float, bool, int>, bio::meta::list_traits::drop_front<list_t>>);
}

drop_last

template<ptrdiff_t i, typename list_t >

using bio::meta::list_traits::drop_last = typedef take<size<list_t> - i, list_t>

Return a meta::type_list of the types the input type list, except the last n.

Template Parameters

i	The amount to drop; must be >= 0 and <= the size of the input type list.
list_t	The (input) type list.

(Compile-time) Complexity

• Number of template instantiations: O(n)
• Other operations: O(n)

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, int>;
 
    // Drop the last two types in list_t.
    static_assert(std::same_as<bio::meta::type_list<int, float>, bio::meta::list_traits::drop_last<2, list_t>>);
}

front

template<typename list_t >

using bio::meta::list_traits::front = typedef typename decltype(detail::front(list_t{}))::type

Return the first type from the type list.

Template Parameters

list_t

The type list.

(Compile-time) Complexity

• Number of template instantiations: O(1)
• Other operations: O(1)

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, int, float>;
 
    static_assert(std::same_as<int, bio::meta::list_traits::front<list_t>>); // Check if the first value is int.
}

repeat

template<size_t count, typename t >

using bio::meta::list_traits::repeat = typedef decltype(detail::repeat<count, t>())

Create a type list with the given type repeated count times..

Template Parameters

count	The number of repititions.
t	The type to repeat

(Compile-time) Complexity

• Number of template instantiations: O(n)
• Other operations: O(n)

However, with a constant of 0.2, e.g. repeat<10,int> results in 2-3 instantiations.

replace_at

template<typename replace_t , std::ptrdiff_t i, typename list_t >

using bio::meta::list_traits::replace_at = typedef decltype(detail::replace_at<replace_t, i>(list_t{}))

Replace the type at the given index with the given type.

Template Parameters

replace_t	The type to replace the old type with.
i	The index of the type to be replaced.
list_t	The (input) type list.

(Compile-time) Complexity

• Number of template instantiations: O(n)
• Other operations: O(n)

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, double>;
 
    // Replace the second element with int.
    static_assert(std::same_as<bio::meta::type_list<int, int, bool, double>, bio::meta::list_traits::replace_at<int, 1, list_t>>);
}

split_after

template<ptrdiff_t i, typename list_t >

using bio::meta::list_traits::split_after = typedef decltype(detail::split_after<i>(list_t{}))

Split a meta::type_list into two parts returned as a pair of meta::type_list.

Template Parameters

i	The number of elements after which to split; must be >= 0 and <= the size of the input type list.
list_t	The (input) type list.

(Compile-time) Complexity

• Number of template instantiations: O(n)
• Other operations: O(n)

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, int>;
 
    // Drop the last two types in list_t.
    static_assert(std::same_as<bio::meta::type_list<int, float>, bio::meta::list_traits::drop_last<2, list_t>>);
}

take

template<ptrdiff_t i, typename list_t >

using bio::meta::list_traits::take = typedef typename decltype(detail::split_after<i>(list_t{}))::first_type

Return a meta::type_list of the first n types in the input type list.

Template Parameters

i	The target size; must be >= 0 and <= the size of the input type list.
list_t	The (input) type list.

(Compile-time) Complexity

• Number of template instantiations: O(n)
• Other operations: O(n)

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, int>;
 
    // Take the first two types in list_t.
    static_assert(std::same_as<bio::meta::type_list<int, float>, bio::meta::list_traits::take<2, list_t>>);
}

take_last

template<ptrdiff_t i, typename list_t >

using bio::meta::list_traits::take_last = typedef drop<size<list_t> - i, list_t>

Return a meta::type_list of the last n types in the input type list.

Template Parameters

i	The target size; must be >= 0 and <= the size of the input type list.
list_t	The (input) type list.

(Compile-time) Complexity

• Number of template instantiations: O(n)
• Other operations: O(n)

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, int>;
 
    // Take the last two types in list_t.
    static_assert(std::same_as<bio::meta::type_list<bool, int>, bio::meta::list_traits::take_last<2, list_t>>);
}

transform

template<template< typename > typename trait_t, typename list_t >

using bio::meta::list_traits::transform = typedef decltype(detail::transform<trait_t>(list_t{}))

Apply a transformation trait to every type in the list and return a meta::type_list of the results.

Template Parameters

trait_t	The trait to transform, must be an alias template, e.g. a transformation trait shortcut.
list_t	The (input) type list.

The transformation trait given as first argument must be an alias template, e.g. std::type_identity_t, not std::type_identity. The alias must take exactly one argument and be defined for all types in the input list.

(Compile-time) Complexity

• Number of template instantiations: O(n)
• Other operations: O(n)

#include <list>
#include <vector>
 
#include <bio/meta/type_list/traits.hpp>
#include <bio/ranges/type_traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<std::vector<int>, std::vector<float>, std::list<bool>>;
 
    // Transform the types into reference types.
    static_assert(std::same_as<bio::meta::list_traits::transform<std::ranges::range_reference_t, list_t>,
                               bio::meta::type_list<int &, float &, bool &>>);
}

Variable Documentation

contains

template<typename query_t , typename list_t >

constexpr bool bio::meta::list_traits::contains = (find<query_t, list_t> != -1)

inlineconstexpr

Whether a type occurs in a type list or not.

(Compile-time) Complexity

• Number of template instantiations: O(1)
• Other operations: O(n), possibly == i, where i is the index of the first occurrence

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, int>;
 
    static_assert(bio::meta::list_traits::contains<double, list_t> == false); // Is type double in type_list list_t?
 
    static_assert(bio::meta::list_traits::contains<float, list_t> == true);   // Is type float in type_list list_t?
}

count< query_t, type_list< pack_t... > >

template<typename query_t , typename... pack_t>

constexpr ptrdiff_t bio::meta::list_traits::count< query_t, type_list< pack_t... > > = meta::detail::pack_traits::count<query_t, pack_t...>

inlineconstexpr

Count the occurrences of a type in a type list.

(Compile-time) Complexity

• Number of template instantiations: O(1)
• Other operations: O(n)

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, int>;
 
    // Count the number of type int in list_t.
    static_assert(bio::meta::list_traits::count<int, list_t> == 2);
}

find< query_t, type_list< pack_t... > >

template<typename query_t , typename... pack_t>

constexpr ptrdiff_t bio::meta::list_traits::find< query_t, type_list< pack_t... > >

inlineconstexpr

Initial value:

=
  meta::detail::pack_traits::detail::find<query_t, pack_t...>()

Get the index of the first occurrence of a type in a type list.

(Compile-time) Complexity

• Number of template instantiations: O(1)
• Other operations: O(n), possibly == i, where i is the return value

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool>;
 
    // Double is not in list_t so find returns -1. However, bool is in the type list so find will return 2.
    static_assert(bio::meta::list_traits::find<double, list_t> == -1);
    static_assert(bio::meta::list_traits::find<bool, list_t> == 2);
}

find_if< pred_t, type_list< pack_t... > >

template<template< typename > typename pred_t, typename... pack_t>

constexpr ptrdiff_t bio::meta::list_traits::find_if< pred_t, type_list< pack_t... > >

inlineconstexpr

Initial value:

=
  meta::detail::pack_traits::detail::find_if<pred_t, pack_t...>()

Get the index of the first type in a type list that satisfies the given predicate.

Note that the predicate must be given as a type template (variable templates cannot be passed as template arguments unfortunately). This means e.g. find_if<std::is_integral, float, double, int, float> (not std::is_integral_v!).

(Compile-time) Complexity

• Number of template instantiations: O(n), possibly == i, where i is the return value

• Other operations: O(n), possibly == i, where i is the return value

  Only the predicate is instantiated.

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, double>;
 
    // None of the types in list_t is a pointer so find_if returns -1. However, int and bool are both integral,
    // so find_if returns 0 for the first occurrence.
    static_assert(bio::meta::list_traits::find_if<std::is_pointer, list_t> == -1);
    static_assert(bio::meta::list_traits::find_if<std::is_integral, list_t> == 0);
}

size< type_list< pack_t... > >

template<typename... pack_t>

constexpr size_t bio::meta::list_traits::size< type_list< pack_t... > > = sizeof...(pack_t)

inlineconstexpr

The size of a type list.

(Compile-time) Complexity

• Number of template instantiations: O(1)
• Other operations: O(1)

#include <bio/meta/type_list/traits.hpp>
 
int main()
{
    using list_t = bio::meta::type_list<int, float, bool, int>;
 
    static_assert(bio::meta::list_traits::size<list_t> == 4);
}