type_traits.hpp File Reference

This file adds basic type traits utilities which are not yet implemented in all standard libraries. More...

#include <type_traits>
#include <utility>

Go to the source code of this file.

Classes
struct	fub::nodeduce< T >
struct	fub::nonesuch
struct	fub::is_detected< Op, Args >
	This is std::true_type if Op<Args...> is a valid SFINAE expression. More...
struct	fub::detected_or< Default, Op, Args >
	Returns the type of Op<Args...> or Default More...
struct	fub::is_detected_exact< Expected, Op, Args >
	This is std::true_type if Op<Args...> is a valid SFINAE expression and the return type is exactly Expected. More...
struct	fub::conjunction<... >
struct	fub::conjunction< B1 >
struct	fub::conjunction< B1, Bn... >
struct	fub::disjunction<... >
struct	fub::disjunction< B1 >
struct	fub::disjunction< B1, Bn... >
struct	fub::integer_sequence< T, Ints >
struct	fub::MakeIntegerSequence_< T, N, N, Ints... >
struct	fub::MakeIntegerSequence_< T, N, L, Ints >
struct	fub::invoke_result< F, Args >
	This is std::true_type if F is a function type and can be invoked with arguments of types Args.... More...
struct	fub::is_invocable< F, Args >
	This is std::true_type if a given object f of type T is callable by fub::invoke(f, args...) for Args... More...
struct	fub::remove_cvref< T >
	This is equivalent to std::remove_cv_t<std::remove_reference_t<T>>. More...
struct	fub::value_type< Var >
struct	fub::is_equality_comparable_impl< T, S >
struct	fub::is_equality_comparable< T, S >
	This is std::true_type if T and S are equality comparable. More...
struct	fub::is_nothrow_equality_comparable< T, S >
	This is std::true_type if T and S are nothrow equality comparable. More...
struct	fub::is_regular< T >
	This type trait checks if a specified type T fulfills the Regular concept. More...
struct	fub::overloaded< Ts >
struct	fub::meta::tag_invoke_fn::tag_invoke_fn
struct	fub::is_tag_invocable< _Tag, _Args >
struct	fub::is_nothrow_tag_invocable< Tag, Args >

Namespaces
	fub
	The fub namespace.
	fub::meta
	The meta namespace.
	fub::meta::tag_invoke_fn
	fub::meta::tag_invoke_ns

Typedefs
using	fub::byte = unsigned char
template<class... >
using	fub::void_t = void
template<typename T >
using	fub::nodeduce_t = typename nodeduce< T >::type
template<template< class... > class Op, class... Args>
using	fub::detected_t = detail::detected_t< Op, Args... >
	Returns the type of Op<Args...> or nonesuch More...
template<class Bool >
using	fub::negation = std::integral_constant< bool, !bool(Bool::value)>
template<std::size_t... Is>
using	fub::index_sequence = integer_sequence< std::size_t, Is... >
template<typename T , T N>
using	fub::make_integer_sequence = typename MakeIntegerSequence_< T, N, T{0}>::type
template<std::size_t N>
using	fub::make_index_sequence = make_integer_sequence< std::size_t, N >
using	fub::index = std::ptrdiff_t
template<bool Bool>
using	fub::bool_constant = std::integral_constant< bool, Bool >
template<index I>
using	fub::index_constant = std::integral_constant< index, I >
template<int I>
using	fub::int_constant = std::integral_constant< int, I >
template<std::size_t I>
using	fub::size_constant = std::integral_constant< std::size_t, I >
template<typename T >
using	fub::remove_cvref_t = typename remove_cvref< T >::type
template<typename Var >
using	fub::value_type_t = typename value_type< Var >::type
template<typename X , typename Y >
using	fub::decays_to = std::is_same< std::decay_t< X >, Y >
template<typename Tag , typename... Args>
using	fub::meta::tag_invoke_fn::tag_invoke_t = decltype(tag_invoke(std::declval< Tag >(), std::declval< Args >()...))
template<typename _Tag , typename... _Args>
using	fub::tag_invoke_result = invoke_result< decltype(fub::meta::tag_invoke), _Tag, _Args... >
template<typename _Tag , typename... _Args>
using	fub::tag_invoke_result_t = invoke_result_t< decltype(fub::meta::tag_invoke), _Tag, _Args... >
template<auto & T>
using	fub::tag_t = std::decay_t< decltype(T)>
template<typename F , typename... Args>
using	fub::invoke_result_t = typename invoke_result< F, Args... >::type

Functions
template<class... Ts>
	fub::overloaded (Ts...) -> overloaded< Ts... >

Variables
template<int I>
static constexpr int_constant< I >	fub::int_c
template<bool B>
static constexpr bool_constant< B >	fub::bool_c
template<index I>
static constexpr index_constant< I >	fub::index_c
template<std::size_t I>
static constexpr size_constant< I >	fub::size_c
constexpr tag_invoke_fn::tag_invoke_fn	fub::meta::tag_invoke_ns::tag_invoke

Detailed Description

This file adds basic type traits utilities which are not yet implemented in all standard libraries.