XIEITE_ARROW(), XIEITE_ARROW_RET(), XIEITE_ARROW_IF(), XIEITE_ARROW_CHOOSE(), XIEITE_ARROW_TRY(), XIEITE_ARROW_DECL(), XIEITE_ARROW_CTOR()

 Defined in header <xieite/pp/arrow.hpp>

Deduplicates the repetition required for defining the body, noexcept specifier, and requires clause of a template function consisting of a single expression.
(i.e. eliminates annoying typing when defining forwarding function templates.)


Definitions

 #arrow 
#define XIEITE_ARROW(...) \
	noexcept __VA_OPT__( \
		(noexcept(__VA_ARGS__)) \
		-> decltype(auto) \
		requires(requires { __VA_ARGS__; }) \
	) { return __VA_ARGS__; }

#arrow-ret 
#define XIEITE_ARROW_RET(...) \
	noexcept __VA_OPT__( \
		(noexcept(__VA_ARGS__)) \
		requires(requires { __VA_ARGS__; }) \
	) { return __VA_ARGS__; }
Same as #arrow but does not specify a trailing return type. Useful for cast operators.

#arrow-if 
#define XIEITE_ARROW_IF(cond_, then_, ...) \
	noexcept(/* ??? */) \
	-> decltype(auto) \
	requires(/* ??? */) \
	{ if constexpr (cond_) { (then_); } return __VA_ARGS__; }
cond_ is explicitly cast to bool.

#arrow-choose 
#define XIEITE_ARROW_CHOOSE(cond_, then_, ...) \
	noexcept(/* ??? */) \
	-> decltype(auto) \
	requires(/* ??? */) \
	{ if constexpr (cond_) { return then_; } else { return __VA_ARGS__; } }
cond_ is explicitly cast to bool. then_ may optionally be wrapped in parentheses.

#arrow-try 
#define XIEITE_ARROW_TRY(body_, ...) \
	noexcept(/* ??? */) \
	-> decltype(auto) \
	requires(requires { body_; /* ??? */ }) \
	{ /* try { return body_; } catch (???) { return ???; } ??? */ }
Accepts a try body followed by a list of catch parameters and their bodies, respectively, in alternating order. All arguments may optionally be wrapped in parentheses. All parameters must be named, and empty parameters are replaced with ....

#arrow-decl 
#define XIEITE_ARROW_DECL(params_, ...) \
	noexcept(requires (/* ??? */) { requires(noexcept(__VA_ARGS__)); }) \
	-> decltype(auto) \
	requires(requires (/* ??? */) { __VA_ARGS__; }) \
	{ return __VA_ARGS__; }
params_ may optionally be wrapped in parentheses if passing one variable, and must be wrapped in parentheses if passing multiple. Passing a variable within an additional set of parentheses designates it as a pack.
Can be used as a workaround to compiler bugs (GCC, Clang) that prevent lambdas outside the function body from capturing function parameters:
 auto f(auto x) XIEITE_ARROW_DECL(x, [=] { x; }())

#arrow-ctor 
#define XIEITE_ARROW_CTOR(body_, ...) \
	noexcept(/* ??? */) \
	requires(/* ??? */) \
	: /* ??? */ \
	{ /* ??? */ }
Accepts a constructor body consisting of, at most, one expression (optionally wrapped in parentheses), followed by a list of things to initialize and what to initialize them with, respectively, in alternating order. Values must be wrapped in two sets of parentheses, unless the intention is to brace-initialize, in which case they must be wrapped in one outer set of parentheses and one inner set of brackets. Wrapping the thing to initialize in one set of parentheses designates it as a base class type, and wrapping it in two sets of parentheses designates it as a pack of base class types. See [Example #1].


Examples

 #0 
auto add(auto a, auto b)
	XIEITE_ARROW(a + b)

struct S {
	void operator+(S) {} // not marked `noexcept`
};

int main() {
	xieite::dump(noexcept(add(1, 2)));
	xieite::dump(noexcept(add(S(), S())));
}
Output: 
true
false
[View in Compiler Explorer]

#1 
template<typename T, typename... Ts>
struct X : T, Ts... {
	int x[2];

	X(int a, int b, auto arg, auto... args)
		XIEITE_ARROW_CTOR(, x, ({ a, b }), (T), ((arg)), ((Ts)), ((args...)))
	// : x { a, b }, T(arg), Ts(args...)... {}
};

struct A { int a; };
struct B { double b0, b1; };
struct C { double c0, c1; };
static_assert(noexcept(X<A, B, C>(1, 2, 418, 3.14159, 6.28318)));
// : x { 1, 2 }, A(418), B(3.14159, 6.28318), C(3.14159, 6.28318) {}
[View in Compiler Explorer]