std::apply_result

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

Symbols index

External libraries

 

Metaprogramming library

Type traits (C++11)

Compile-time rational arithmetic (C++11)

Compile-time integer sequences (C++14)

integer_sequence (C++14)

Compile-time reflection (C++26)

 

Type traits

Type traits (since C++11)

Type categories is_void is_null_pointer (DR*) is_reflection (C++26) is_array is_pointer is_enum is_union is_class is_function is_reference      is_object is_scalar is_compound is_integral is_floating_point      is_fundamental is_arithmetic is_lvalue_reference is_rvalue_reference is_member_pointer is_member_object_pointer is_member_function_pointer Type properties is_const is_volatile is_empty is_polymorphic is_final (C++14) is_abstract is_aggregate (C++17) is_structural (C++26) is_implicit_lifetime (C++23) is_trivial (deprecated in C++26) is_trivially_copyable is_standard_layout is_literal_type (until C++20*) is_pod (deprecated in C++20) is_signed is_unsigned is_bounded_array (C++20) is_unbounded_array (C++20) is_scoped_enum (C++23) has_unique_object_   representations (C++17)     Type trait constants integral_constantbool_constanttrue_typefalse_type (C++17) Metafunctions conjunction (C++17) disjunction (C++17) negation (C++17)

Supported operations is_constructibleis_trivially_constructibleis_nothrow_constructible is_default_constructibleis_trivially_default_constructibleis_nothrow_default_constructible is_copy_constructibleis_trivially_copy_constructibleis_nothrow_copy_constructible is_move_constructibleis_trivially_move_constructibleis_nothrow_move_constructible is_assignableis_trivially_assignableis_nothrow_assignable is_copy_assignableis_trivially_copy_assignableis_nothrow_copy_assignable is_move_assignableis_trivially_move_assignableis_nothrow_move_assignable is_destructibleis_trivially_destructibleis_nothrow_destructible has_virtual_destructor is_swappable_withis_swappableis_nothrow_swappable_withis_nothrow_swappable (C++17)(C++17)(C++17)(C++17) Relationships and property queries is_same is_convertibleis_nothrow_convertible (C++20) is_layout_compatible (C++20) is_pointer_interconvertible_base_of (C++20) is_pointer_interconvertible_with_class (C++20)     is_corresponding_member (C++20) reference_constructs_from_temporary (C++23) reference_converts_from_temporary (C++23) alignment_of is_base_of is_virtual_base_of (C++26) rank extent is_invocableis_invocable_ris_nothrow_invocableis_nothrow_invocable_r (C++17)(C++17)(C++17)(C++17) is_applicableis_nothrow_applicable (C++26)(C++26) Type modifications remove_cvremove_constremove_volatile add_cvadd_constadd_volatile make_signed make_unsigned remove_reference add_lvalue_referenceadd_rvalue_reference remove_pointer add_pointer remove_extent remove_all_extents Type transformations aligned_storage (deprecated in C++23) aligned_union (deprecated in C++23) decay remove_cvref (C++20) result_ofinvoke_result (until C++20*)(C++17) apply_result (C++26) conditional common_type common_reference (C++20) underlying_type type_identity (C++20) enable_if void_t (C++17)

 

Defined in header <type_traits>
template< class Fn, class Tuple > class apply_result;		(since C++26)

See More

Deduces the return type of an INVOKE expression.

Let /*ELEMS-OF*/(T) be the parameter pack std::get<N>(std::declval<T>()), where N is the pack of std::size_t template arguments of the specialization of std::index_sequence denoted by std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<T>>>.

If tuple-like<Tuple> is true and the expression /*INVOKE*/(std::declval<Fn>(), /*ELEMS-OF*/(Tuple)...) is well-formed when treated as an unevaluated operand, the member typedef type denotes the type decltype(/*INVOKE*/(declval<Fn>(), /*ELEMS-OF*/(Tuple)...)); otherwise, there is no member type.

Access checking is performed as if in a context unrelated to Fn and Tuple. Only the validity of the immediate context of the expression is considered.

The compilation of the expression can result in side effects such as the instantiation of class template specializations and function template specializations, the generation of implicitly-defined functions, and so on. Such side effects are not in the “immediate context” and can result in the program being ill-formed.

If Fn or Tuple is not a complete type, (possibly cv-qualified) void, or an array of unknown bound, the behavior is undefined.

If an instantiation of a template above depends, directly or indirectly, on an incomplete type, and that instantiation could yield a different result if that type were hypothetically completed, the behavior is undefined.

If the program adds specializations for any of the templates described on this page, the behavior is undefined.

Member types

Member type	Description
type	the return type of the Callable type Fn if invoked with the arguments given in Tuple. Only defined if Fn can be called with the arguments in Tuple in unevaluated context.

Helper types

template< class Fn, class Tuple > using apply_result_t = apply_result<Fn, Tuple>::type;		(since C++26)

Possible implementation

namespace detail
{
template<std::size_t I, class T>
using element_at = decltype(std::get<I>(std::declval<T>()));

template<class Fn, class T, std::size_t ... I>
constexpr auto apply_impl(Fn&& f, T&& t, std::index_sequence<I...>)
    noexcept (std::is_nothrow_invocable_v<Fn, element_at<I, T >...>)
        -> std::invoke_result_t<Fn, element_at<I, T>...>
{
    return std::invoke(std::forward<Fn>(f), std::get<I>(std::forward<T>(t))...);
}

template<class Fn, class Tuple>
using apply_result_t = decltype(apply_impl(
    std::declval<Fn>(),
    std::declval<Tuple>(),
    std::make_index_sequence<std::tuple_size_v<std::remove_reference_t<Tuple>>>())
);

template <class Fn, class Tuple>
struct apply_result_impl {}; // exposition-only

template<class Fn, class Tuple>
    requires requires { typename std::apply_result_t<Fn, Tuple>; }
struct apply_result_impl<Fn, Tuple >
{
    using type = std::apply_result_t<Fn, Tuple>;
};
} // namespace detail

template<class Fn, class Tuple>
struct apply_result : detail::apply_result_impl<Fn, Tuple>{};

Notes

std::apply_result (and the corresponding alias std::apply_result_t) is used in the return type of std::apply.(since C++26)

Feature-test macro	Value	Std	Feature
__cpp_lib_reflection	202506L	(C++26)	<meta>: Reflection library support.

Examples

Run this code

#include <type_traits>

struct S
{
    double operator()(char, int&);
    float operator()(int) { return 1.0f; }
};

int main()
{
    std::apply_result_t<S, char, int&> a{3.14};
    static_assert(std::is_same_v<decltype(a), double>);

    std::apply_result_t<S, int> b{2.71f};
    static_assert(std::is_same_v<decltype(b), float>);
}

See also

apply (C++17)	calls a function with a tuple of arguments (function template)
invokeinvoke_r (C++17)(C++23)	invokes any Callable object with given arguments and possibility to specify return type(since C++23) (function template)
result_ofinvoke_result (C++11)(removed in C++20)(C++17)	deduces the result type of invoking a callable object with a set of arguments (class template)
declval (C++11)	obtains a reference to an object of the template type argument for use in an unevaluated context (function template)
invocableregular_invocable (C++20)(C++20)	specifies that a callable type can be invoked with a given set of argument types (concept)
is_invocableis_invocable_ris_nothrow_invocableis_nothrow_invocable_r (C++17)(C++17)(C++17)(C++17)	checks if a type can be invoked (as if by std::invoke) with the given argument types (class template)
is_invocable_typeis_invocable_r_typeis_nothrow_invocable_typeis_nothrow_invocable_r_type (C++26)(C++26)(C++26)(C++26)	checks if the reflected type can be invoked (as if by std::invoke) with the given argument types (function template)
is_applicableis_nothrow_applicable (C++26)(C++26)	checks if a type can be invoked (as if by std::invoke) with the given tuple of arguments (class template)
apply_result (C++26)	deduces the result type of invoking a callable object with the given reflected tuple of arguments (function)