如何在嵌套上下文中通过 __VA_OPT__ 扩展递归宏

Question

我读过这篇文章，它说明了如何__VA_OPT__使用函数宏来递归扩展宏。我想实现类似的东西，不同之处在于宏是在嵌套上下文中扩展的。

输入：

NEST_RECURSIVE(A, B, C)

应该产生（顺序无关）：

((( | C) | B) | A)

我的方法稍微概括了这篇文章：

#define PARENS ()

#define EXPAND(...) EXPAND4(EXPAND4(EXPAND4(EXPAND4(__VA_ARGS__))))
#define EXPAND4(...) EXPAND3(EXPAND3(EXPAND3(EXPAND3(__VA_ARGS__))))
#define EXPAND3(...) EXPAND2(EXPAND2(EXPAND2(EXPAND2(__VA_ARGS__))))
#define EXPAND2(...) EXPAND1(EXPAND1(EXPAND1(EXPAND1(__VA_ARGS__))))
#define EXPAND1(...) __VA_ARGS__

#define FOR_EACH_R(func, ...) __VA_OPT__(EXPAND(FOR_EACH_HELPER_R(func, __VA_ARGS__)))
#define FOR_EACH_HELPER_R(func, sub, ...) func(__VA_OPT__(FOR_EACH_AGAIN_R PARENS (func, __VA_ARGS__)), sub)
#define FOR_EACH_AGAIN_R() FOR_EACH_HELPER_R

#define MY_FUNC(nested, var) (nested | var)
#define NEST_RECURSIVE(...) FOR_EACH_R(MY_FUNC, __VA_ARGS__)

当前代码产生以下输出：

(FOR_EACH_HELPER_R (MY_FUNC, B, C) | A)

可以看出，扩展不会发生在第一级之后。

我想我必须EXPAND别的地方，但是，我不知道在哪里。

我想要做的事情完全有可能是不可能的，但是，C++20 之前的递归宏扩展方法（利用PP_NARG）确实适用于嵌套，所以我希望新的、更干净的方法可以使用它还有！

Answer 1

您的基础是正确的，导致问题的是对宏内的FOR_EACH_R调用。funcFOR_EACH_HELPER_R

您可以通过暂时删除它来验证这一点：

/* ... */
#define FOR_EACH_HELPER_R(func, sub, ...) (__VA_OPT__(FOR_EACH_AGAIN_R PARENS (func, __VA_ARGS__)), sub)
/* ... */

NEST_RECURSIVE(A, B, C)

神箭示例

会导致：

(((, C), B), A)

1. 宏观评估如何运作

宏观评估不是很直观，所以我将快速解释对此答案很重要的两个概念：

1.1 类函数宏求值顺序

例子：

#define FOO() 1
#define BAR() 2
#define BAZ(A, B) MIAU(A, B)
#define MIAU(A, B) B A

BAZ(FOO(), BAR())

当预处理器看到调用时，BAZ()会发生以下事情：

• 1. 参数经过充分评估：
  • FOO()-> 1
  • BAR()-> 2
• 2. 计算值被代入宏体中：
  • BAZ(1, 2)->MIAU(1, 2)
• 3. 宏体再次全面评估
  • MIAU(1, 2)->2 1

因此，参数可能会被评估两次 - 一次是在它们被替换到宏主体之前，然后是在评估主体时再次。

这也是为什么您可以将宏作为参数传递给其他宏，例如：

#define FOO(fn) fn()
#define BAR() 12

FOO(BAR)

这里会发生以下事情：

• 1. 预处理器完全评估参数：
     BAR确实命名了宏，但它不是宏调用。因此预处理器不会评估它并将其视为文本：BAR
• 2. 代入宏体：
     FOO(BAR)->BAR()
• 3. 身材评价：
     BAR()->12

您的EXPAND宏还使用它来重复强制对表达式求值。

1.2 不能从自身调用宏

例如：

#define FOO 1 + FOO

FOO

#define BAR 1 + BAZ
#define BAZ BAR

BAR

• FOO会导致1 + FOO
• BAR会导致1 + BAR

本质上，当预处理器正在评估给定的宏时，例如，其中（或它调用的宏之一）中BAR出现的任何情况都将被标记为不要尝试评估此 - 永远。BAR

所以基本上一旦宏看到它自己的名字，游戏就结束了。

2. 为什么你的例子不起作用

让我们来看看宏的评估FOR_EACH_R：（EXPAND为了简单起见，我将省略宏）

1. 第一EXPAND回合

• 首先我们从FOR_EACH_HELPER_R(MY_FUNC, A, B, C)
• 代入正文：MY_FUNC(FOR_EACH_AGAIN_R PARENS (MY_FUNC, B, C), A)
• 然后评估身体
  • 预处理器看到对 的调用MY_FUNC，因此将评估两个参数：
    • FOR_EACH_AGAIN_R PARENS (MY_FUNC, B, C)变为FOR_EACH_AGAIN_R () (MY_FUNC, B, C)（由于FOR_EACH_AGAIN_R不是直接调用，因此未进一步评估）
    • A->A
• 代入MY_FUNC正文：
  MY_FUNC((FOR_EACH_AGAIN_R () (MY_FUNC, B, C)), A)
  ->
  (FOR_EACH_AGAIN_R () (MY_FUNC, B, C) | A)
• 评估主体： (FOR_EACH_AGAIN_R () (MY_FUNC, B, C) | A)
  ->
  (FOR_EACH_HELPER_R (MY_FUNC, B, C) | A)
  ->
  预处理器检测到递归（我们正在其中MY_FUNC被调用FOR_EACH_HELPER_R，并且我们正尝试在此处再次调用FOR_EACH_HELPER_R）
  ，因此FOR_EACH_HELPER_R将被标记为不要尝试评估此
  参数 ，另外MY_FUNC参数也将被标记（因为我们进来了MY_FUNC）

2. EXPAND之后的每一轮

• 预处理器尝试计算当前表达式：
  (FOR_EACH_HELPER_R (MY_FUNC, B, C) | A) 但FOR_EACH_HELPER_R被标记为不要尝试计算 this，因此该调用被忽略并且没有任何内容被替换。

-> 你最终得到的(FOR_EACH_HELPER_R (MY_FUNC, B, C) | A)输出

3. 如何修复

最大的问题是你FOR_EACH_AGAIN_R(...)作为参数传递给你的func，它将对该部分求值两次（一次作为参数，一次在主体中），因此预处理器看到递归调用并停止。

您可以通过延迟FOR_EACH_AGAIN_R另一个评估周期来部分修复它，例如：

/* ... */
#define FOR_EACH_HELPER_R(func, sub, ...) func (__VA_OPT__(FOR_EACH_AGAIN_R PARENS (func, __VA_ARGS__)), sub)
#define FOR_EACH_AGAIN_R() FOR_EACH_AGAIN_R_IMPL PARENS
#define FOR_EACH_AGAIN_R_IMPL() FOR_EACH_HELPER_R
/* ... */

神箭示例

这将导致：

(MY_FUNC (MY_FUNC (, C), B) | A)

现在循环已完全扩展，但是仍然存在递归问题MY_FUNC。
这里的根本问题是 的参数之一将MY_FUNC包含MY_FUNC，例如：

MY_FUNC((FOR_EACH_AGAIN_R PARENS (MY_FUNC, B, C)), A)

因此，一旦预处理器替换MY_FUNC该MY_FUNC标记，将立即将其标记为不要再次尝试对其求值。
因此，MY_FUNC在第一次调用后，链条就卡住了。

如果您不需要递归调用，那么会容易得多，例如：

/* ... */
#define FOR_EACH_HELPER_R(func, sub, ...) __VA_OPT__(FOR_EACH_AGAIN_R PARENS (func, __VA_ARGS__)), func(sub)
/* ... */
#define MY_FUNC(var) (var)
/* ... */

神箭示例

会毫无问题地工作（结果将是, (C), (B), (A)）

如果您绝对需要递归调用，那么只有一种方法：

您需要确保MY_FUNC永远不会看到FOR_EACH_HELPER_R& MY_FUNC。
但考虑到每次调用都需要前一次调用的结果，您唯一的选择是以一次性评估MY_FUNC所有调用的方式构建宏。MY_FUNC

例如，您需要以FOR_EACH_HELPER_R这样的方式构建，最终您会得到：

MY_FUNC(MY_FUNC(MY_FUNC(, C), B), A)

以便正确评估递归调用。

确保这一点的最简单方法是使用与 相同的延迟技巧FOR_EACH_AGAIN_R，例如使用一组如下宏：

#define DELAY6(...) DELAY6_IMPL PARENS __VA_OPT__((__VA_ARGS__))
#define DELAY5(...) DELAY5_IMPL PARENS __VA_OPT__((__VA_ARGS__))
#define DELAY4(...) DELAY4_IMPL PARENS __VA_OPT__((__VA_ARGS__))
#define DELAY3(...) DELAY3_IMPL PARENS __VA_OPT__((__VA_ARGS__))
#define DELAY2(...) DELAY2_IMPL PARENS __VA_OPT__((__VA_ARGS__))
#define DELAY1(...) DELAY1_IMPL PARENS __VA_OPT__((__VA_ARGS__))
#define DELAY0(...) __VA_ARGS__

#define DELAY6_IMPL() DELAY5
#define DELAY5_IMPL() DELAY4
#define DELAY4_IMPL() DELAY3
#define DELAY3_IMPL() DELAY2
#define DELAY2_IMPL() DELAY1
#define DELAY1_IMPL() DELAY0

因此DELAY6将延迟 6 次评估、DELAY55 次评估，等等......

然后你可以用它来延迟对 的调用MY_FUNC，例如：

#define FOR_EACH_R(func, ...) __VA_OPT__(EXPAND(FOR_EACH_HELPER_R(func, DELAY6, __VA_ARGS__)))
#define FOR_EACH_HELPER_R(func, del, sub, ...) del(func) (__VA_OPT__(FOR_EACH_AGAIN_R PARENS (func, del(), __VA_ARGS__)), sub)

请注意，我们正在传递del()，而不是传递del到 的下一次迭代FOR_EACH_HELPER_R，这将有效地导致下一个较低的DELAY*函数被传递（以便所有延迟在一次评估中解决）

这样NEST_RECURSIVE(A, B, C, D, E, F, G)将评估如下：

DELAY5_IMPL () (MY_FUNC) (DELAY5_IMPL () (MY_FUNC) (FOR_EACH_AGAIN_R () (MY_FUNC, DELAY5_IMPL () , C, D, E, F, G), B), A)
->
DELAY4_IMPL () (MY_FUNC) (DELAY4_IMPL () (MY_FUNC) (DELAY4_IMPL () (MY_FUNC) (FOR_EACH_AGAIN_R () (MY_FUNC, DELAY4_IMPL () , D, E, F, G), C), B), A)
->
DELAY3_IMPL () (MY_FUNC) (DELAY3_IMPL () (MY_FUNC) (DELAY3_IMPL () (MY_FUNC) (DELAY3_IMPL () (MY_FUNC) (FOR_EACH_AGAIN_R () (MY_FUNC, DELAY3_IMPL () , E, F, G), D), C), B), A)
->
DELAY2_IMPL () (MY_FUNC) (DELAY2_IMPL () (MY_FUNC) (DELAY2_IMPL () (MY_FUNC) (DELAY2_IMPL () (MY_FUNC) (DELAY2_IMPL () (MY_FUNC) (FOR_EACH_AGAIN_R () (MY_FUNC, DELAY2_IMPL () , F, G), E), D), C), B), A)
->
DELAY1_IMPL () (MY_FUNC) (DELAY1_IMPL () (MY_FUNC) (DELAY1_IMPL () (MY_FUNC) (DELAY1_IMPL () (MY_FUNC) (DELAY1_IMPL () (MY_FUNC) (DELAY1_IMPL () (MY_FUNC) (FOR_EACH_AGAIN_R () (MY_FUNC, DELAY1_IMPL () , G), F), E), D), C), B), A)
->
((((((( | G) | F) | E) | D) | C) | B) | A)

神箭示例

请注意，MY_FUNC直到最后一轮评估才被调用 - 这基本上确保了所有 MY_FUNC 调用都会立即评估，并且我们不会遇到递归宏调用的任何问题。

不过，您必须定义很多DELAY_宏才能使其工作（每个附加参数都需要 1 个延迟宏FOR_EACH_R）

完整代码示例：godbolt

#define PARENS ()

#define EXPAND(...) EXPAND4(EXPAND4(EXPAND4(EXPAND4(__VA_ARGS__))))
#define EXPAND4(...) EXPAND3(EXPAND3(EXPAND3(EXPAND3(__VA_ARGS__))))
#define EXPAND3(...) EXPAND2(EXPAND2(EXPAND2(EXPAND2(__VA_ARGS__))))
#define EXPAND2(...) EXPAND1(EXPAND1(EXPAND1(EXPAND1(__VA_ARGS__))))
#define EXPAND1(...) __VA_ARGS__

#define DELAY6(...) DELAY6_IMPL PARENS __VA_OPT__((__VA_ARGS__))
#define DELAY5(...) DELAY5_IMPL PARENS __VA_OPT__((__VA_ARGS__))
#define DELAY4(...) DELAY4_IMPL PARENS __VA_OPT__((__VA_ARGS__))
#define DELAY3(...) DELAY3_IMPL PARENS __VA_OPT__((__VA_ARGS__))
#define DELAY2(...) DELAY2_IMPL PARENS __VA_OPT__((__VA_ARGS__))
#define DELAY1(...) DELAY1_IMPL PARENS __VA_OPT__((__VA_ARGS__))
#define DELAY0(...) __VA_ARGS__



#define DELAY6_IMPL() DELAY5
#define DELAY5_IMPL() DELAY4
#define DELAY4_IMPL() DELAY3
#define DELAY3_IMPL() DELAY2
#define DELAY2_IMPL() DELAY1
#define DELAY1_IMPL() DELAY0


#define FOR_EACH_R(func, ...) __VA_OPT__(EXPAND(FOR_EACH_HELPER_R(func, DELAY6, __VA_ARGS__)))
#define FOR_EACH_HELPER_R(func, del, sub, ...) del(func) (__VA_OPT__(FOR_EACH_AGAIN_R PARENS (func, del(), __VA_ARGS__)), sub)
#define FOR_EACH_AGAIN_R() FOR_EACH_HELPER_R

#define MY_FUNC(nested, var) (nested | var)
#define NEST_RECURSIVE(...) FOR_EACH_R(MY_FUNC, __VA_ARGS__)

NEST_RECURSIVE(A, B, C, D, E, F, G)

4. 可能更好的方法

4.1 简单宏链

上述解决方案需要很好地理解如何评估宏以了解发生的情况。您还可以通过定义一堆宏来选择更简单的方法，例如boost 所做的

例如：

#define FOR_EACH_ERROR()

#define FOR_EACH_R(fn, ...) __VA_OPT__(FOR_EACH_R_IMPL_0(fn, __VA_ARGS__))
#define FOR_EACH_R_IMPL_0(fn, el, ...) fn(__VA_OPT__(FOR_EACH_R_IMPL_1(fn, __VA_ARGS__)), el)
#define FOR_EACH_R_IMPL_1(fn, el, ...) fn(__VA_OPT__(FOR_EACH_R_IMPL_2(fn, __VA_ARGS__)), el)
#define FOR_EACH_R_IMPL_2(fn, el, ...) fn(__VA_OPT__(FOR_EACH_R_IMPL_3(fn, __VA_ARGS__)), el)
#define FOR_EACH_R_IMPL_3(fn, el, ...) fn(__VA_OPT__(FOR_EACH_R_IMPL_4(fn, __VA_ARGS__)), el)
#define FOR_EACH_R_IMPL_4(fn, el, ...) fn(__VA_OPT__(FOR_EACH_R_IMPL_5(fn, __VA_ARGS__)), el)
#define FOR_EACH_R_IMPL_5(fn, el, ...) fn(__VA_OPT__(FOR_EACH_R_IMPL_6(fn, __VA_ARGS__)), el)
#define FOR_EACH_R_IMPL_6(fn, el, ...) fn(__VA_OPT__(FOR_EACH_R_IMPL_7(fn, __VA_ARGS__)), el)
#define FOR_EACH_R_IMPL_7(fn, el, ...) fn(__VA_OPT__(FOR_EACH_R_IMPL_8(fn, __VA_ARGS__)), el)
#define FOR_EACH_R_IMPL_8(fn, el, ...) fn(__VA_OPT__(FOR_EACH_R_IMPL_9(fn, __VA_ARGS__)), el)
#define FOR_EACH_R_IMPL_9(fn, el, ...) fn(__VA_OPT__(FOR_EACH_R_IMPL_10(fn, __VA_ARGS__)), el)
#define FOR_EACH_R_IMPL_10(...) FOR_EACH_ERROR("Shenanigans!")


#define MY_FUNC(nested, var) (nested | var)
#define NEST_RECURSIVE(...) FOR_EACH_R(MY_FUNC, __VA_ARGS__)

NEST_RECURSIVE(A, B, C, D, E, F, G)

神箭示例

这更容易理解并且也很容易扩展（只需添加更多宏）

4.2 递归左折叠

如果您希望递归版本减少需要编写的行数，可以通过使用左折叠来实现，例如：

// Recursive Left Fold
#define FOR_EACH_L(fn, ...) __VA_OPT__(FOR_EACH_APPLY0(FOR_EACH_RESULT, FOR_EACH_L_4(fn,,__VA_ARGS__)))

#define FOR_EACH_L_4(fn, res, ...) FOR_EACH_APPLY4(FOR_EACH_L_3, FOR_EACH_APPLY4(FOR_EACH_L_3, FOR_EACH_APPLY4(FOR_EACH_L_3, fn, res __VA_OPT__(, __VA_ARGS__))))
#define FOR_EACH_L_3(fn, res, ...) FOR_EACH_APPLY3(FOR_EACH_L_2, FOR_EACH_APPLY3(FOR_EACH_L_2, FOR_EACH_APPLY3(FOR_EACH_L_2, fn, res __VA_OPT__(, __VA_ARGS__))))
#define FOR_EACH_L_2(fn, res, ...) FOR_EACH_APPLY2(FOR_EACH_L_1, FOR_EACH_APPLY2(FOR_EACH_L_1, FOR_EACH_APPLY2(FOR_EACH_L_1, fn, res __VA_OPT__(, __VA_ARGS__))))
#define FOR_EACH_L_1(fn, res, ...) FOR_EACH_APPLY1(FOR_EACH_L_0, FOR_EACH_APPLY1(FOR_EACH_L_0, FOR_EACH_APPLY1(FOR_EACH_L_0, fn, res __VA_OPT__(, __VA_ARGS__))))
#define FOR_EACH_L_0(fn, res, ...) fn, FOR_EACH_FIRST(__VA_OPT__(fn(res, FOR_EACH_FIRST(__VA_ARGS__)), ) res) __VA_OPT__(FOR_EACH_TAIL(__VA_ARGS__))

#define FOR_EACH_APPLY4(fn, ...) fn(__VA_ARGS__)
#define FOR_EACH_APPLY3(fn, ...) fn(__VA_ARGS__)
#define FOR_EACH_APPLY2(fn, ...) fn(__VA_ARGS__)
#define FOR_EACH_APPLY1(fn, ...) fn(__VA_ARGS__)
#define FOR_EACH_APPLY0(fn, ...) fn(__VA_ARGS__)
#define FOR_EACH_FIRST(el, ...) el
#define FOR_EACH_TAIL(el, ...) __VA_OPT__(, __VA_ARGS__)
#define FOR_EACH_RESULT(fn, res, ...) res

神箭示例

左折叠比右折叠更容易实现，因为获取第一个元素__VA_ARGS__比获取最后一个元素容易得多（FOR_EACH_FIRST在上面的示例中）。

上面提供的版本最多可以处理 81 个参数，如果您需要更多参数，只需创建更多版本的FOR_EACH_L_*&FOR_EACH_APPLY*宏。（这些宏中的每个附加宏都会使其可以处理的最大参数数量增加三倍）

不过，您确实需要以相反的顺序提供参数，因为它是左折叠，例如：

NEST_RECURSIVE(A, B, C, D, E, F, G)
// would result in ((((((( | A) | B) | C) | D) | E) | F) | G)

如果您需要右折叠，您可以通过反转参数然后调用我们上面创建的左折叠变体来实现它。

例如：

// Reverse args
#define PARENS ()

#define EXPAND(...) EXPAND4(EXPAND4(EXPAND4(EXPAND4(__VA_ARGS__))))
#define EXPAND4(...) EXPAND3(EXPAND3(EXPAND3(EXPAND3(__VA_ARGS__))))
#define EXPAND3(...) EXPAND2(EXPAND2(EXPAND2(EXPAND2(__VA_ARGS__))))
#define EXPAND2(...) EXPAND1(EXPAND1(EXPAND1(EXPAND1(__VA_ARGS__))))
#define EXPAND1(...) __VA_ARGS__

#define REVERSE(...) __VA_OPT__(EXPAND(REVERSE_HELPER(__VA_ARGS__)))
#define REVERSE_HELPER(el, ...) __VA_OPT__(REVERSE_AGAIN PARENS (__VA_ARGS__), ) el
#define REVERSE_AGAIN() REVERSE_HELPER

神箭示例

（这也仅适用于最多 81 个参数，您可以添加更多EXPAND*宏来增加它可以处理的参数数量）

例子：

REVERSE(A, B, C, D, E, F, G)
// would result in G, F, E, D, C, B, A

然后你可以像这样实现正确的折叠：

// Right fold
#define FOR_EACH_R(fn, ...) __VA_OPT__(FOR_EACH_R_APPLY(FOR_EACH_L, fn, REVERSE(__VA_ARGS__)))
#define FOR_EACH_R_APPLY(fn, ...) fn(__VA_ARGS__)

神箭示例

最终给出预期结果（最多 81 个参数），例如：

NEST_RECURSIVE(A, B, C, D, E, F, G)
// would result in: ((((((( | G) | F) | E) | D) | C) | B) | A)

完整代码：godbolt

// Reverse args
#define PARENS ()

#define EXPAND(...) EXPAND4(EXPAND4(EXPAND4(EXPAND4(__VA_ARGS__))))
#define EXPAND4(...) EXPAND3(EXPAND3(EXPAND3(EXPAND3(__VA_ARGS__))))
#define EXPAND3(...) EXPAND2(EXPAND2(EXPAND2(EXPAND2(__VA_ARGS__))))
#define EXPAND2(...) EXPAND1(EXPAND1(EXPAND1(EXPAND1(__VA_ARGS__))))
#define EXPAND1(...) __VA_ARGS__

#define REVERSE(...) __VA_OPT__(EXPAND(REVERSE_HELPER(__VA_ARGS__)))
#define REVERSE_HELPER(el, ...) __VA_OPT__(REVERSE_AGAIN PARENS (__VA_ARGS__), ) el
#define REVERSE_AGAIN() REVERSE_HELPER

// Recursive Left Fold
#define FOR_EACH_L(fn, ...) __VA_OPT__(FOR_EACH_APPLY0(FOR_EACH_RESULT, FOR_EACH_L_4(fn,,__VA_ARGS__)))

#define FOR_EACH_L_4(fn, res, ...) FOR_EACH_APPLY4(FOR_EACH_L_3, FOR_EACH_APPLY4(FOR_EACH_L_3, FOR_EACH_APPLY4(FOR_EACH_L_3, fn, res __VA_OPT__(, __VA_ARGS__))))
#define FOR_EACH_L_3(fn, res, ...) FOR_EACH_APPLY3(FOR_EACH_L_2, FOR_EACH_APPLY3(FOR_EACH_L_2, FOR_EACH_APPLY3(FOR_EACH_L_2, fn, res __VA_OPT__(, __VA_ARGS__))))
#define FOR_EACH_L_2(fn, res, ...) FOR_EACH_APPLY2(FOR_EACH_L_1, FOR_EACH_APPLY2(FOR_EACH_L_1, FOR_EACH_APPLY2(FOR_EACH_L_1, fn, res __VA_OPT__(, __VA_ARGS__))))
#define FOR_EACH_L_1(fn, res, ...) FOR_EACH_APPLY1(FOR_EACH_L_0, FOR_EACH_APPLY1(FOR_EACH_L_0, FOR_EACH_APPLY1(FOR_EACH_L_0, fn, res __VA_OPT__(, __VA_ARGS__))))
#define FOR_EACH_L_0(fn, res, ...) fn, FOR_EACH_FIRST(__VA_OPT__(fn(res, FOR_EACH_FIRST(__VA_ARGS__)), ) res) __VA_OPT__(FOR_EACH_TAIL(__VA_ARGS__))

#define FOR_EACH_APPLY4(fn, ...) fn(__VA_ARGS__)
#define FOR_EACH_APPLY3(fn, ...) fn(__VA_ARGS__)
#define FOR_EACH_APPLY2(fn, ...) fn(__VA_ARGS__)
#define FOR_EACH_APPLY1(fn, ...) fn(__VA_ARGS__)
#define FOR_EACH_APPLY0(fn, ...) fn(__VA_ARGS__)
#define FOR_EACH_FIRST(el, ...) el
#define FOR_EACH_TAIL(el, ...) __VA_OPT__(, __VA_ARGS__)
#define FOR_EACH_RESULT(fn, res, ...) res

// Right fold
#define FOR_EACH_R(fn, ...) __VA_OPT__(FOR_EACH_R_APPLY(FOR_EACH_L, fn, REVERSE(__VA_ARGS__)))
#define FOR_EACH_R_APPLY(fn, ...) fn(__VA_ARGS__)

// For testing
#define MY_FUNC(nested, var) (nested | var)
#define NEST_RECURSIVE(...) FOR_EACH_R(MY_FUNC, __VA_ARGS__)


NEST_RECURSIVE(A, B, C, D, E, F, G)