std::meta::is_invocable_type, std::meta::is_invocable_r_type, std::meta::is_nothrow_invocable_type, std::meta::is_nothrow_invocable_r_type

 

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)

 

Reflection library

Checking string literals is_string_literal Types info meta::exception access_context data_member_options member_offset operators Concepts reflection_range Promoting to static storage reflect_constant_string reflect_constant_array define_static_string define_static_array define_static_object Operator representations operator_of symbol_of u8symbol_of Names and locations has_identifier identifier_of u8identifier_of display_string_of u8display_string_of source_location_of Reflection queries ➜ Member accessibility queries is_accessible has_inaccessible_nonstatic_   data_members has_inaccessible_bases has_inaccessible_subobjects

Scope identification current_function current_class current_namespace Reflection member queries members_of bases_of static_data_members_of nonstatic_data_members_of      subobjects_of enumerators_of Reflection layout queries offset_of size_of alignment_of bit_size_of Annotation reflection annotations_of annotations_of_with_type Value extraction extract Reflection substitution can_substitute substitute Expression result reflection reflect_constant reflect_object reflect_function Class definition generation data_member_spec is_data_member_spec define_aggregate

Primary type categories is_void_type is_null_pointer_type is_integral_type is_floating_point_type is_array_type is_pointer_type is_lvalue_reference_type is_rvalue_reference_type is_member_object_pointer_type is_member_function_pointer_type      is_enum_type is_union_type is_class_type is_function_type is_reflection_type Composite type categories is_reference_type is_arithmetic_type is_fundamental_type is_object_type is_scalar_type is_compound_type is_member_pointer_type Type properties ➜ Type relations is_same_type is_base_of_type is_virtual_base_of_type is_convertible_type is_nothrow_convertible_type is_layout_compatible_type is_pointer_interconvertible_   base_of_type is_invocable_type is_invocable_r_type is_nothrow_invocable_type is_nothrow_invocable_r_type

Const-volatile modifications remove_const remove_volatile remove_cv add_const add_volatile add_cv Reference modifications remove_reference add_lvalue_reference add_rvalue_reference Sign modifications make_signed make_unsigned Array modifications remove_extent remove_all_extents Pointer modifications remove_pointer add_pointer Other transformations remove_cvref decay common_type common_reference underlying_type invoke_result unwrap_reference unwrap_ref_decay tuple_size tuple_element is_applicable_type is_nothrow_applicable_type apply_result variant_size variant_alternative type_order

 

Reflection types and queries

Reflection queries type_of object_of constant_of is_public is_protected is_private is_virtual is_pure_virtual is_override is_final is_deleted is_defaulted is_user_provided is_user_declared is_explicit is_noexcept is_bit_field is_enumerator is_annotation is_const is_volatile is_mutable_member is_lvalue_reference_qualified is_rvalue_reference_qualified has_static_storage_duration has_thread_storage_duration has_automatic_storage_duration      has_internal_linkage has_module_linkage has_external_linkage has_linkage has_c_language_linkage is_complete_type is_enumerable_type is_variable is_type is_namespace is_type_alias is_namespace_alias is_function is_conversion_function is_operator_function is_literal_operator is_special_member_function is_destructor

is_constructor is_default_constructor is_copy_constructor is_move_constructor is_assignment is_copy_assignment is_move_assignment is_function_parameter is_explicit_object_parameter has_default_argument is_vararg_function is_template is_function_template is_variable_template is_class_template is_alias_template is_conversion_function_template      is_operator_function_template is_literal_operator_template is_constructor_template is_concept is_value is_object is_structured_binding is_class_member is_namespace_member is_nonstatic_data_member is_static_member is_base has_default_member_initializer has_parent parent_of dealias has_template_arguments template_of template_arguments_of parameters_of variable_of return_type_of Type properties is_const_type is_volatile_type is_trivially_copyable_type is_standard_layout_type is_empty_type

is_polymorphic_type is_abstract_type is_final_type is_aggregate_type is_structural_type is_signed_type is_unsigned_type is_bounded_array_type is_unbounded_array_type is_scoped_enum_type is_constructible_type is_trivially_constructible_type is_nothrow_constructible_type is_default_constructible_type is_trivially_default_constructible_type is_nothrow_default_constructible_type is_copy_constructible_type is_trivially_copy_constructible_type is_nothrow_copy_constructible_type is_move_constructible_type is_trivially_move_constructible_type is_nothrow_move_constructible_type is_assignable_type is_trivially_assignable_type is_nothrow_assignable_type is_copy_assignable_type is_trivially_copy_assignable_type is_nothrow_copy_assignable_type is_move_assignable_type is_trivially_move_assignable_type is_nothrow_move_assignable_type is_swappable_with_type is_swappable_type is_nothrow_swappable_with_type is_nothrow_swappable_type is_destructible_type is_trivially_destructible_type is_nothrow_destructible_type is_implicit_lifetime_type has_virtual_destructor has_unique_object_representations reference_constructs_from_temporary reference_converts_from_temporary Type property queries rank extent

 

Defined in header <meta>
template< std::meta::reflection_range Args = std::initializer_list<std::meta::info> > consteval bool is_invocable_type( std::meta::info fn_type, Args&& arg_types );	(1)	(since C++26)
template< std::meta::reflection_range Args = std::initializer_list<std::meta::info> > consteval bool is_invocable_r_type( std::meta::info result_type, std::meta::info fn_type, Args&& arg_types );	(2)	(since C++26)
template< std::meta::reflection_range Args = std::initializer_list<std::meta::info> > consteval bool is_nothrow_invocable_type( std::meta::info fn_type, Args&& arg_types );	(3)	(since C++26)
template< std::meta::reflection_range Args = std::initializer_list<std::meta::info> > consteval bool is_nothrow_invocable_r_type( std::meta::info result_type, std::meta::info fn_type, Args&& arg_types );	(4)	(since C++26)

Determines if the reflected type can be invoked (as if by std::invoke) with the given argument types.

Let

• Fn be the type or type alias represented by fn_type,
• Result be the type or type alias represented by result_type, and
• ARGS... be the pack of types or type aliases whose elements are represented by the corresponding elements of arg_types.

1) Equivalent to return std::is_invocable_v<Fn, ARGS...>;.

2) Equivalent to return std::is_invocable_r_v<Result, Fn, ARGS...>;.

3) Equivalent to return std::is_nothrow_invocable_v<Fn, ARGS...>;.

4) Equivalent to return std::is_nothrow_invocable_r_v<Result, Fn, ARGS...>;.

Template parameters

Args

-

an initializer list the elements of which represent the types of invocation arguments

Parameters

fn_type	-	reflected invocable object type
arg_types	-	reflected argument types of invocation
result_type	-	reflected result type of invocation

Return value

true if reflected type fn_type can be invoked with the given argument types. Otherwise, false.

Exceptions

Throws std::meta::exception:

• If either fn_type, result_type or any element of arg_types does not represent a type or type alias.
• If Fn, Result or any type in the pack ARGS... is not a complete type, (possibly cv-qualified) void, or an array of unknown bound.
• If an instantiation of a template (1-4) depends, directly or indirectly, on an incomplete type, and that instantiation could yield a different result if that type were hypothetically completed.

Example

Run this code

#include <meta>

auto func(char) -> int(*)();

static_assert
(""
    &&  is_invocable_type(^^void(int, char), {^^int, ^^char})
    && !is_invocable_type(^^void(void), {^^int})
    &&  is_invocable_type(^^decltype(func), {^^char})
    && !is_invocable_type(^^decltype(int()), {^^int})
    &&  is_invocable_r_type(^^void, ^^void(int), {^^int})
    && !is_invocable_r_type(^^void, ^^void(int), {^^void})
    &&  is_invocable_r_type(^^int(*)(), ^^decltype(func), {^^char})
    && !is_invocable_r_type(^^int(*)(), ^^decltype(func), {^^void})
);

int main() {}

See also

invokeinvoke_r (C++17)(C++23)	invokes any Callable object with given arguments and possibility to specify return type(since C++23) (function template)
invoke_result (C++26)	deduces the result type of invoking a callable object with a set of arguments (function template)
is_applicable_typeis_nothrow_applicable_type (C++26)(C++26)	checks if the callable object can be invoked (as if by std::invoke) with a tuple of arguments (function)
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)