ReactiveCocoa 中 奇妙无比的“宏”魔法
前言
在ReactiveCocoa 中，开源库做者为咱们提供了不少种魔法，“黑”魔法，“红”魔法……今天就让先来看看“红”魔法。程序员
在ReactiveCocoa 中，封装了不少很是实用的“宏”，使用这些“宏”为咱们开发带来了不少的便利。编程
今天就来盘点一下RAC中的宏是如何实现的。vim
目录
- 1.关于宏
- 2.ReactiveCocoa 中的元宏
- 3.ReactiveCocoa 中经常使用的宏
一. 关于宏
宏（Macro），是一种批量处理的称谓。数组
在编程领域里的宏是一种抽象（Abstraction），它根据一系列预约义的规则替换必定的文本模式。解释器或编译器在遇到宏时会自动进行这一模式替换。绝大多数状况下，“宏”这个词的使用暗示着将小命令或动做转化为一系列指令。闭包
宏的用途在于自动化频繁使用的序列或者是得到一种更强大的抽象能力。
计算机语言如C语言或汇编语言有简单的宏系统，由编译器或汇编器的预处理器实现。C语言的宏预处理器的工做只是简单的文本搜索和替换，使用附加的文本处理语言如M4，C程序员能够得到更精巧的宏。编辑器
Lisp类语言如Common Lisp和Scheme有更精巧的宏系统：宏的行为如同是函数对自身程序文本的变形，而且能够应用所有语言来表达这种变形。一个C宏能够定义一段语法的替换，然而一个Lisp的宏却能够控制一节代码的计算。函数
对于编译语言来讲，全部的宏都是在预编译的时候被展开的，因此在lex进行词法扫描生成Token，词法分析过程以前，全部的宏都已经被展开完成了。源码分析
对于Xcode，预处理或者预编译阶段是能够直接查看的。post
随便写一个宏，而后打开Xcode右上方的Assistant，选择“Preprocess”就能够看到该文件预处理以后的样子了。能够看到左边的@weakify(self) 被转换成了右边的两行代码了。测试
关于这个Xcode的这个功能还有2点补充说明：
1.不一样阶段的Preprocessed可能不一样，要根据你的目标去选择预处理的条件。
好比这里就有5种预编译的种类能够选择。
2.宏通过预编译以后出来的代码，是能够用来检测宏写的是否正确的，可是没法看到宏被展开的具体过程。这意味着咱们能够经过Xcode这个功能来查看宏的做用，可是没法知道宏的具体实现。具体实现仍是须要经过查看源码来分析。
ReactiveCocoa中的宏，若是不查看源码分析，会以为那些宏都像魔法同样奇妙无比，接下来就来解开“宏”魔法的神秘面纱。
二. ReactiveCocoa 中的元宏
在ReactiveCocoa的宏中，做者定义了这么一些基础的宏，做为“元宏”，它们是构成以后复杂宏的基础。在分析经常使用宏以前，必需要先分析清楚这些元宏的具体实现。
1. metamacro_stringify(VALUE)
#define metamacro_stringify(VALUE) \ metamacro_stringify_(VALUE) #define metamacro_stringify_(VALUE) # VALUE
metamacro_stringify( )这个宏用到了#的用法。#在宏中表明把宏的参数变为一个字符串。这个宏的目的和它的名字同样明显，把入参VALUE转换成一个字符串返回。
这里可能就有人有疑问，为啥要包装一层，不能直接写成下面这样：
#define metamacro_stringify(VALUE) # VALUE
语意确实也没有变，可是有种特殊状况下就会出现问题。
举个例子：
#define NUMBER 10 #define ADD(a,b) (a+b) NSLog(@"%d+%d=%d",NUMBER, NUMBER, ADD(NUMBER,NUMBER));
输出以下：
10+10=20
这样子确实是没有问题，可是稍做修改就会有问题。
#define STRINGIFY(S) #S #define CALCULATE(A,B) (A##10##B) NSLog(@"int max: %s",STRINGIFY(INT_MAX)); NSLog(@"%d", CALCULATE(NUMBER,NUMBER));
若是是这种状况下，第二个NSLog打印是会编译错误的。上面两句通过预编译以后，宏会被展开成下面这个样子：
NSLog(@"int max: %s","INT_MAX"); NSLog(@"%d", (NUMBER10NUMBER));
能够发现，宏并无再次被展开。解决办法也很简单，就是把宏包装一层，写一个转接宏出来。
#define CALCULATE(A,B) _CALCULATE(A,B) // 转换宏 #define _CALCULATE(A,B) A##10##B
再次测试一下，这里咱们使用官方的metamacro_stringify
NSLog(@"int max: %s",metamacro_stringify(INT_MAX)); NSLog(@"%d", CALCULATE(NUMBER,NUMBER));
这样最终打印出来的结果和咱们想要的一致，没有问题。
2147483647 101010
CALCULATE(NUMBER,NUMBER) 第一层转换成 _CALCULATE(10,10)，接着第二次转换成10##10##10，也就是101010。
固然这里是2层转换，若是有多层转换就须要更多个转换宏了。
NSLog(@"%d", CALCULATE(STRINGIFY(NUMBER),STRINGIFY(NUMBER)));
上面这个例子就是3层了，按照以前咱们的写法仍是编译报错。若是是超过2，3层的多层的状况，就该考虑考虑宏设计的语意的问题，尽可能不让使用者产生错误的用法。
2. metamacro_concat(A, B)
#define metamacro_concat(A, B) \ metamacro_concat_(A, B) #define metamacro_concat_(A, B) A ## B
这个宏就是用来合并入参A，B到一块儿。在RAC里面主要用这个方法来合成另一个宏的名字。
3. metamacro_argcount(...) 和 metamacro_at(N, ...)
metamacro_argcount(...)这个宏设计的也很是巧妙，它是用来获取参数个数的。因为宏展开是在预编译时期的，因此它在预编译时期获取参数个数的，其余非宏的方法都是在运行时获取参数个数的。
#define metamacro_argcount(...) \ metamacro_at(20, __VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
这里会调用metamacro_at(N, ...)宏。
#define metamacro_at(N, ...) \ metamacro_concat(metamacro_at, N)(__VA_ARGS__)
把这个宏展开，因而获得：
#define metamacro_at(N, ...) \ metamacro_atN(__VA_ARGS__)
因而经过metamacro_concat合成命令，就获得了一连串的metamacro_atN宏命令：
#define metamacro_at0(...) metamacro_head(__VA_ARGS__) #define metamacro_at1(_0, ...) metamacro_head(__VA_ARGS__) #define metamacro_at2(_0, _1, ...) metamacro_head(__VA_ARGS__) #define metamacro_at3(_0, _1, _2, ...) metamacro_head(__VA_ARGS__) #define metamacro_at4(_0, _1, _2, _3, ...) metamacro_head(__VA_ARGS__) #define metamacro_at5(_0, _1, _2, _3, _4, ...) metamacro_head(__VA_ARGS__) #define metamacro_at6(_0, _1, _2, _3, _4, _5, ...) metamacro_head(__VA_ARGS__) #define metamacro_at7(_0, _1, _2, _3, _4, _5, _6, ...) metamacro_head(__VA_ARGS__) #define metamacro_at8(_0, _1, _2, _3, _4, _5, _6, _7, ...) metamacro_head(__VA_ARGS__) #define metamacro_at9(_0, _1, _2, _3, _4, _5, _6, _7, _8, ...) metamacro_head(__VA_ARGS__) #define metamacro_at10(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, ...) metamacro_head(__VA_ARGS__) #define metamacro_at11(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, ...) metamacro_head(__VA_ARGS__) #define metamacro_at12(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, ...) metamacro_head(__VA_ARGS__) #define metamacro_at13(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, ...) metamacro_head(__VA_ARGS__) #define metamacro_at14(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, ...) metamacro_head(__VA_ARGS__) #define metamacro_at15(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, ...) metamacro_head(__VA_ARGS__) #define metamacro_at16(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) metamacro_head(__VA_ARGS__) #define metamacro_at17(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, ...) metamacro_head(__VA_ARGS__) #define metamacro_at18(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, ...) metamacro_head(__VA_ARGS__) #define metamacro_at19(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, ...) metamacro_head(__VA_ARGS__) #define metamacro_at20(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ...) metamacro_head(__VA_ARGS__)
可见N的取值只能从0到20。
#define metamacro_head(...) \ metamacro_head_(__VA_ARGS__, 0) #define metamacro_head_(FIRST, ...) FIRST
metamacro_head展开以后变成：
#define metamacro_head(FIRST,..., 0) FIRST
metamacro_head的意图就很明显，是用来获取后面可变入参的第一个参数。
回到metamacro_atN宏上面来，那么把它展开就是下面这样：
#define metamacro_atN(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ... , _N, ...) metamacro_head(__VA_ARGS__)
固然，N的取值仍是从0到20，那么metamacro_atN宏获取到的值就是可变参数列表里面的第N个参数值。参数从0开始。
再回到最初的metamacro_argcount(...)宏，目前展开到这一步：
#define metamacro_argcount(...) \ metamacro_at20(__VA_ARGS__, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
因为__VA_ARGS__个数不能超过20个，因此一定是在0-19之间。
metamacro_at20(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, ..., 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1) metamacro_head(__VA_ARGS__)
假设入参是有5个：
metamacro_argcount(@"1",@"2",@"3",@"4",@"5");
先把5个参数放入metamacro_at20的前五个位置。而后从第6个位置开始倒序插入20-1的数字。以下图：
咱们能够把倒序的数字想象成一把尺子，是用来衡量或者指示当前有多少个参数的。尺子的最左边对齐上面20个空位的第一位，尺子后面多出来的部分，取出来，而后进行metamacro_head操做，取出第一位参数，这个数字就是整个参数的个数了。这把虚拟的“尺子”是会左右对齐的，具体的位置就要根据填入参数的个数来决定的。
这个宏的原理也很简单，20 - （ 20 - n ）= n。metamacro_argcount(...) 宏就是这样在预编译时期获取到参数个数的。
做者也标明了，这个宏的设计灵感来自于P99神库，有兴趣的同窗能够去看看这个库。
4. metamacro_foreach(MACRO, SEP, ...) 和 metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)
先来分析分析metamacro_foreach(MACRO, SEP, ...) 宏：
#define metamacro_foreach(MACRO, SEP, ...) \ metamacro_foreach_cxt(metamacro_foreach_iter, SEP, MACRO, __VA_ARGS__)
看到定义就知道metamacro_foreach(MACRO, SEP, ...) 和 metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...) 是同样的做用。前者只不过比后者少了一个foreach的迭代子。
1. metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏
再来看看metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏的定义。
#define metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...) \ metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(__VA_ARGS__))(MACRO, SEP, CONTEXT, __VA_ARGS__)
那么以前的metamacro_foreach(MACRO, SEP, ...)宏就能够等价于
metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(__VA_ARGS__))(metamacro_foreach_iter, SEP, MACRO, __VA_ARGS__)
回到metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏的展开表达式上面来，假设__VA_ARGS__的参数个数为N。
metamacro_concat 宏 和 metamacro_argcount 宏上面介绍过了，那么能够继续把宏展开成下面的样子：
metamacro_foreach_cxtN(MACRO, SEP, CONTEXT, __VA_ARGS__)
这里又是利用metamacro_concat 宏动态的合并成了另外一个宏的例子。
#define metamacro_foreach_cxt0(MACRO, SEP, CONTEXT) #define metamacro_foreach_cxt1(MACRO, SEP, CONTEXT, _0) MACRO(0, CONTEXT, _0) #define metamacro_foreach_cxt2(MACRO, SEP, CONTEXT, _0, _1) \ metamacro_foreach_cxt1(MACRO, SEP, CONTEXT, _0) \ SEP \ MACRO(1, CONTEXT, _1) #define metamacro_foreach_cxt3(MACRO, SEP, CONTEXT, _0, _1, _2) \ metamacro_foreach_cxt2(MACRO, SEP, CONTEXT, _0, _1) \ SEP \ MACRO(2, CONTEXT, _2) #define metamacro_foreach_cxt4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \ metamacro_foreach_cxt3(MACRO, SEP, CONTEXT, _0, _1, _2) \ SEP \ MACRO(3, CONTEXT, _3) #define metamacro_foreach_cxt5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \ metamacro_foreach_cxt4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \ SEP \ MACRO(4, CONTEXT, _4) #define metamacro_foreach_cxt6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \ metamacro_foreach_cxt5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \ SEP \ MACRO(5, CONTEXT, _5) #define metamacro_foreach_cxt7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \ metamacro_foreach_cxt6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \ SEP \ MACRO(6, CONTEXT, _6) #define metamacro_foreach_cxt8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \ metamacro_foreach_cxt7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \ SEP \ MACRO(7, CONTEXT, _7) #define metamacro_foreach_cxt9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \ metamacro_foreach_cxt8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \ SEP \ MACRO(8, CONTEXT, _8) #define metamacro_foreach_cxt10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \ metamacro_foreach_cxt9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \ SEP \ MACRO(9, CONTEXT, _9) #define metamacro_foreach_cxt11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \ metamacro_foreach_cxt10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \ SEP \ MACRO(10, CONTEXT, _10) #define metamacro_foreach_cxt12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \ metamacro_foreach_cxt11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \ SEP \ MACRO(11, CONTEXT, _11) #define metamacro_foreach_cxt13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \ metamacro_foreach_cxt12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \ SEP \ MACRO(12, CONTEXT, _12) #define metamacro_foreach_cxt14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \ metamacro_foreach_cxt13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \ SEP \ MACRO(13, CONTEXT, _13) #define metamacro_foreach_cxt15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \ metamacro_foreach_cxt14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \ SEP \ MACRO(14, CONTEXT, _14) #define metamacro_foreach_cxt16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \ metamacro_foreach_cxt15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \ SEP \ MACRO(15, CONTEXT, _15) #define metamacro_foreach_cxt17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \ metamacro_foreach_cxt16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \ SEP \ MACRO(16, CONTEXT, _16) #define metamacro_foreach_cxt18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \ metamacro_foreach_cxt17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \ SEP \ MACRO(17, CONTEXT, _17) #define metamacro_foreach_cxt19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \ metamacro_foreach_cxt18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \ SEP \ MACRO(18, CONTEXT, _18) #define metamacro_foreach_cxt20(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) \ metamacro_foreach_cxt19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \ SEP \ MACRO(19, CONTEXT, _19)
把上述的metamacro_foreach_cxtN的定义抽象一下：
#define metamacro_foreach_cxtN(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, … ,_N - 1) \ metamacro_foreach_cxtN - 1(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, … ,_N - 2) \ SEP \ MACRO(N - 1, CONTEXT, _N - 1)
固然，在RAC中N的取值范围是[0,20]。咱们仍是假设N的定义域是全体非负整数组成的集合N(数学中的非负整数集合的标志) 。那么咱们把metamacro_foreach_cxtN彻底展开到不能展开为止：
MACRO(0, CONTEXT, _0) \ SEP \ MACRO(1, CONTEXT, _1) \ SEP \ MACRO(2, CONTEXT, _2) \ SEP \ MACRO(3, CONTEXT, _3) \ …… …… …… …… …… …… SEP \ MACRO(N - 4, CONTEXT, _N - 4) \ SEP \ MACRO(N - 3, CONTEXT, _N - 3) \ SEP \ MACRO(N - 2, CONTEXT, _N - 2) \ SEP \ MACRO(N - 1, CONTEXT, _N - 1)
metamacro_foreach_cxtN(MACRO, SEP, CONTEXT, ...)，这个宏的意图也就很明显了，从可变参数列表里面读取出个数，而后把每一个参数都进行一次MACRO(N - 1, CONTEXT, _N - 1)操做，每一个操做直接用SEP做为分隔符进行分隔。
metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)这个宏的设计灵感也来自于P99库。
用到这个宏最著名的的宏就是weakify(...)了，下面来简要的看看是如何利用metamacro_foreach_cxtN(MACRO, SEP, CONTEXT, ...)巧妙的实现weakify(...)的。
#define weakify(...) \ rac_keywordify \ metamacro_foreach_cxt(rac_weakify_,, __weak, __VA_ARGS__)
使用weakify和平时咱们本身写的weakSelf最大的区别就是，weakify后面是能够跟多个参数的，最多多达20个。weakify能够一口气把参数列表里面全部的参数都进行weak操做。
weakify(...)的重点之一就在metamacro_foreach_cxt操做上。假设传入2个参数，self和str，进行展开以后获得：
MACRO(0, CONTEXT, _0) \ SEP \ MACRO(1, CONTEXT, _1)
MACRO = rac_weakify_，CONTEXT = __weak，SEP 为 空格 ，代入参数：
rac_weakify_(0,__weak,self) \ rac_weakify_(1,__weak,str)
注意，替换完成以后，两个宏是连在一块儿的，中间没有分号！分隔符SEP目前是空格。最后一步就是替换掉rac_weakify_：
#define rac_weakify_(INDEX, CONTEXT, VAR) \ CONTEXT __typeof__(VAR) metamacro_concat(VAR, _weak_) = (VAR);
注意这里的INDEX是废参数，并无被用到。
展开上面的宏：
__weak __typeof__(self) self_weak_ = (self)；__weak __typeof__(str) str_weak_ = (str)；
注意，rac_weakify_是自带分号的，若是此处没有分号，这里会出现编译错误。
最终@weakify(self，str) 就会在预编译期间被替换成
@autoreleasepool {} __weak __typeof__(self) self_weak_ = (self)；__weak __typeof__(str) str_weak_ = (str)；
注意中间是没有换行的，此处宏展开以后就是一行。
metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)分析完毕以后再回过来看看metamacro_foreach(MACRO, SEP, ...)
2. metamacro_foreach(MACRO, SEP, ...)
metamacro_concat(metamacro_foreach_cxt, metamacro_argcount(__VA_ARGS__))(metamacro_foreach_iter, SEP, MACRO, __VA_ARGS__)
此时一样能够假设参数个数为N，那么上述宏展开能够变成下面的样子：
metamacro_foreach_cxtN(metamacro_foreach_iter, SEP, MACRO, __VA_ARGS__)
这里的MACRO = metamacro_foreach_iter，SEP = SEP ， CONTEXT = MACRO。
metamacro_foreach_iter(0, MACRO, _0) \ SEP \ metamacro_foreach_iter(1, MACRO, _1) \ SEP \ metamacro_foreach_iter(2, MACRO, _2) \ SEP \ metamacro_foreach_iter(3, MACRO, _3) \ …… …… …… …… …… …… SEP \ metamacro_foreach_iter(N - 4, MACRO, _N - 4) \ SEP \ metamacro_foreach_iter(N - 3, MACRO, _N - 3) \ SEP \ metamacro_foreach_iter(N - 2, MACRO, _N - 2) \ SEP \ metamacro_foreach_iter(N - 1, MACRO, _N - 1)
metamacro_foreach_iter 定义以下：
#define metamacro_foreach_iter(INDEX, MACRO, ARG) MACRO(INDEX, ARG)
继续展开获得下面的式子：
MACRO(0, _0) \ SEP \ MACRO(1, _1) \ SEP \ MACRO(2, _2) \ SEP \ MACRO(3, _3) \ …… …… …… …… …… …… SEP \ MACRO(N - 4, _N - 4) \ SEP \ MACRO(N - 3, _N - 3) \ SEP \ MACRO(N - 2, _N - 2) \ SEP \ MACRO(N - 1, _N - 1)
从最终的展开式子上来看，metamacro_foreach(MACRO, SEP, ...) 就比 metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...) 少了一个CONTEXT。
metamacro_foreach(MACRO, SEP, ...)这个宏的典型例子就是熟知的strongify(...)的实现。
#define strongify(...) \ rac_keywordify \ _Pragma("clang diagnostic push") \ _Pragma("clang diagnostic ignored \"-Wshadow\"") \ metamacro_foreach(rac_strongify_,, __VA_ARGS__) \ _Pragma("clang diagnostic pop")
经过上面的分析，咱们直接替换结果，MACRO = rac_strongify_ ，SEP = 空格。
rac_strongify_(0, _0) \ rac_strongify_(1, _1) \ rac_strongify_(2, _2) \ rac_strongify_(3, _3) \ …… …… …… …… …… …… rac_strongify_(N - 4, _N - 4) \ rac_strongify_(N - 3, _N - 3) \ rac_strongify_(N - 2, _N - 2) \ rac_strongify_(N - 1, _N - 1)
接下来替换掉rac_strongify_
#define rac_strongify_(INDEX, VAR) \ __strong __typeof__(VAR) VAR = metamacro_concat(VAR, _weak_);
一样的，这里的INDEX也是一个废参数，也没有用到。rac_strongify_一样的自带分号，若是此处没有分号，SEP此时也是空格，编译就直接报错。
最终就转换成以下的样子：
__strong __typeof__(self) self = self_weak_;
5. metamacro_foreach_cxt_recursive(MACRO, SEP, CONTEXT, ...)
先来看看定义：
#define metamacro_foreach_cxt_recursive(MACRO, SEP, CONTEXT, ...) \ metamacro_concat(metamacro_foreach_cxt_recursive, metamacro_argcount(__VA_ARGS__))(MACRO, SEP, CONTEXT, __VA_ARGS__)
假设可变参数个数为N，将上面式子展开：
#define metamacro_foreach_cxt_recursive(MACRO, SEP, CONTEXT, ...) \ metamacro_foreach_cxt_recursiveN(MACRO, SEP, CONTEXT, __VA_ARGS__)
因而就转换成了metamacro_foreach_cxt_recursiveN 宏：
#define metamacro_foreach_cxt_recursive0(MACRO, SEP, CONTEXT) #define metamacro_foreach_cxt_recursive1(MACRO, SEP, CONTEXT, _0) MACRO(0, CONTEXT, _0) #define metamacro_foreach_cxt_recursive2(MACRO, SEP, CONTEXT, _0, _1) \ metamacro_foreach_cxt_recursive1(MACRO, SEP, CONTEXT, _0) \ SEP \ MACRO(1, CONTEXT, _1) #define metamacro_foreach_cxt_recursive3(MACRO, SEP, CONTEXT, _0, _1, _2) \ metamacro_foreach_cxt_recursive2(MACRO, SEP, CONTEXT, _0, _1) \ SEP \ MACRO(2, CONTEXT, _2) #define metamacro_foreach_cxt_recursive4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \ metamacro_foreach_cxt_recursive3(MACRO, SEP, CONTEXT, _0, _1, _2) \ SEP \ MACRO(3, CONTEXT, _3) #define metamacro_foreach_cxt_recursive5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \ metamacro_foreach_cxt_recursive4(MACRO, SEP, CONTEXT, _0, _1, _2, _3) \ SEP \ MACRO(4, CONTEXT, _4) #define metamacro_foreach_cxt_recursive6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \ metamacro_foreach_cxt_recursive5(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4) \ SEP \ MACRO(5, CONTEXT, _5) #define metamacro_foreach_cxt_recursive7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \ metamacro_foreach_cxt_recursive6(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5) \ SEP \ MACRO(6, CONTEXT, _6) #define metamacro_foreach_cxt_recursive8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \ metamacro_foreach_cxt_recursive7(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6) \ SEP \ MACRO(7, CONTEXT, _7) #define metamacro_foreach_cxt_recursive9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \ metamacro_foreach_cxt_recursive8(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7) \ SEP \ MACRO(8, CONTEXT, _8) #define metamacro_foreach_cxt_recursive10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \ metamacro_foreach_cxt_recursive9(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8) \ SEP \ MACRO(9, CONTEXT, _9) #define metamacro_foreach_cxt_recursive11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \ metamacro_foreach_cxt_recursive10(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9) \ SEP \ MACRO(10, CONTEXT, _10) #define metamacro_foreach_cxt_recursive12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \ metamacro_foreach_cxt_recursive11(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \ SEP \ MACRO(11, CONTEXT, _11) #define metamacro_foreach_cxt_recursive13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \ metamacro_foreach_cxt_recursive12(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11) \ SEP \ MACRO(12, CONTEXT, _12) #define metamacro_foreach_cxt_recursive14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \ metamacro_foreach_cxt_recursive13(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12) \ SEP \ MACRO(13, CONTEXT, _13) #define metamacro_foreach_cxt_recursive15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \ metamacro_foreach_cxt_recursive14(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13) \ SEP \ MACRO(14, CONTEXT, _14) #define metamacro_foreach_cxt_recursive16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \ metamacro_foreach_cxt_recursive15(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14) \ SEP \ MACRO(15, CONTEXT, _15) #define metamacro_foreach_cxt_recursive17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \ metamacro_foreach_cxt_recursive16(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15) \ SEP \ MACRO(16, CONTEXT, _16) #define metamacro_foreach_cxt_recursive18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \ metamacro_foreach_cxt_recursive17(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16) \ SEP \ MACRO(17, CONTEXT, _17) #define metamacro_foreach_cxt_recursive19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \ metamacro_foreach_cxt_recursive18(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17) \ SEP \ MACRO(18, CONTEXT, _18) #define metamacro_foreach_cxt_recursive20(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19) \ metamacro_foreach_cxt_recursive19(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18) \ SEP \ MACRO(19, CONTEXT, _19)
提取一下metamacro_foreach_cxt_recursiveN的定义：
#define metamacro_foreach_cxt_recursiveN(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, … ，_( N - 1)) \ metamacro_foreach_cxt_recursive(N - 1)(MACRO, SEP, CONTEXT, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _( N - 2)) \ SEP \ MACRO(N -1, CONTEXT, _N -1)
仍是按照以前分析的，同理彻底展开：
MACRO(0, CONTEXT, _0) \ SEP \ MACRO(1, CONTEXT, _1) \ SEP \ MACRO(2, CONTEXT, _2) \ SEP \ MACRO(3, CONTEXT, _3) \ …… …… …… …… …… …… SEP \ MACRO(N - 4, CONTEXT, _N - 4) \ SEP \ MACRO(N - 3, CONTEXT, _N - 3) \ SEP \ MACRO(N - 2, CONTEXT, _N - 2) \ SEP \ MACRO(N - 1, CONTEXT, _N - 1)
至此，展开式与metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏彻底相同。
这个递归的宏历来没有在RAC的其余宏中使用，做者在这里标注说明了这个宏的用处。
This can be used when the former would fail due to recursive macro expansion
因为宏在递归展开中可能会致使递归前置条件失败，在这种状况下，应该使用这个递归宏。固然，它的效果和metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏是彻底同样的。
6. metamacro_foreach_concat(BASE, SEP, ...)
这个宏定义是套用了metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏的实现，只是多传入了一些参数。因而可知，metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏在RAC中的重要性。
#define metamacro_foreach_concat(BASE, SEP, ...) \ metamacro_foreach_cxt(metamacro_foreach_concat_iter, SEP, BASE, __VA_ARGS__)
因为在上面详细分析过了metamacro_foreach_cxt(MACRO, SEP, CONTEXT, ...)宏的实现，那么这里就直接彻底展开到最后一步。MACRO = metamacro_foreach_concat_iter，SEP = SEP，CONTEXT = BASE。
metamacro_foreach_concat_iter(0, BASE, _0) \ SEP \ metamacro_foreach_concat_iter(1, BASE, _1) \ SEP \ metamacro_foreach_concat_iter(2, BASE, _2) \ SEP \ metamacro_foreach_concat_iter(3, BASE, _3) \ …… …… …… …… …… …… SEP \ metamacro_foreach_concat_iter(N - 4, BASE, _N - 4) \ SEP \ metamacro_foreach_concat_iter(N - 3, BASE, _N - 3) \ SEP \ metamacro_foreach_concat_iter(N - 2, BASE, _N - 2) \ SEP \ metamacro_foreach_concat_iter(N - 1, BASE, _N - 1)
到了这一步，就须要继续展开metamacro_foreach_concat_iter
#define metamacro_foreach_concat_iter(INDEX, BASE, ARG) metamacro_foreach_concat_iter_(BASE, ARG) #define metamacro_foreach_concat_iter_(BASE, ARG) BASE ## ARG
这里的2个宏，就用到了以前说道的转接宏的概念，由于须要把第一个参数剔除，因此须要写一个转接宏，转换一次踢掉第一个参数。
最终彻底展开就是下面的样子：
BASE_0 \
SEP \
BASE_1 \
SEP \
BASE_2 \
SEP \
BASE_3 \
……
……
……
……
……
……
SEP \
BASE_N - 4 \ SEP \ BASE_N - 3 \ SEP \ BASE_N - 2 \ SEP \ BASE_N - 1
metamacro_foreach_concat(BASE, SEP, ...)宏如同它的名字同样，把可变参数里面每一个参数都拼接到BASE后面，每一个参数拼接完成之间都用SEP分隔。
试想一种场景：
若是有一连串的方法，方法名都有一个相同的前缀，后面是不一样的。这种场景下，利用metamacro_foreach_concat(BASE, SEP, ...)宏是很是爽的，它会一口气组合出相关的一列表的不一样的宏。
7. metamacro_for_cxt(COUNT, MACRO, SEP, CONTEXT)
定义以下：
#define metamacro_for_cxt(COUNT, MACRO, SEP, CONTEXT) \ metamacro_concat(metamacro_for_cxt, COUNT)(MACRO, SEP, CONTEXT)
metamacro_concat 以前分析过，展开这一层：
metamacro_for_cxtN(MACRO, SEP, CONTEXT)
metamacro_for_cxtN的定义以下：
#define metamacro_for_cxt0(MACRO, SEP, CONTEXT) #define metamacro_for_cxt1(MACRO, SEP, CONTEXT) MACRO(0, CONTEXT) #define metamacro_for_cxt2(MACRO, SEP, CONTEXT) \ metamacro_for_cxt1(MACRO, SEP, CONTEXT) \ SEP \ MACRO(1, CONTEXT) #define metamacro_for_cxt3(MACRO, SEP, CONTEXT) \ metamacro_for_cxt2(MACRO, SEP, CONTEXT) \ SEP \ MACRO(2, CONTEXT) #define metamacro_for_cxt4(MACRO, SEP, CONTEXT) \ metamacro_for_cxt3(MACRO, SEP, CONTEXT) \ SEP \ MACRO(3, CONTEXT) #define metamacro_for_cxt5(MACRO, SEP, CONTEXT) \ metamacro_for_cxt4(MACRO, SEP, CONTEXT) \ SEP \ MACRO(4, CONTEXT) #define metamacro_for_cxt6(MACRO, SEP, CONTEXT) \ metamacro_for_cxt5(MACRO, SEP, CONTEXT) \ SEP \ MACRO(5, CONTEXT) #define metamacro_for_cxt7(MACRO, SEP, CONTEXT) \ metamacro_for_cxt6(MACRO, SEP, CONTEXT) \ SEP \ MACRO(6, CONTEXT) #define metamacro_for_cxt8(MACRO, SEP, CONTEXT) \ metamacro_for_cxt7(MACRO, SEP, CONTEXT) \ SEP \ MACRO(7, CONTEXT) #define metamacro_for_cxt9(MACRO, SEP, CONTEXT) \ metamacro_for_cxt8(MACRO, SEP, CONTEXT) \ SEP \ MACRO(8, CONTEXT) #define metamacro_for_cxt10(MACRO, SEP, CONTEXT) \ metamacro_for_cxt9(MACRO, SEP, CONTEXT) \ SEP \ MACRO(9, CONTEXT) #define metamacro_for_cxt11(MACRO, SEP, CONTEXT) \ metamacro_for_cxt10(MACRO, SEP, CONTEXT) \ SEP \ MACRO(10, CONTEXT) #define metamacro_for_cxt12(MACRO, SEP, CONTEXT) \ metamacro_for_cxt11(MACRO, SEP, CONTEXT) \ SEP \ MACRO(11, CONTEXT) #define metamacro_for_cxt13(MACRO, SEP, CONTEXT) \ metamacro_for_cxt12(MACRO, SEP, CONTEXT) \ SEP \ MACRO(12, CONTEXT) #define metamacro_for_cxt14(MACRO, SEP, CONTEXT) \ metamacro_for_cxt13(MACRO, SEP, CONTEXT) \ SEP \ MACRO(13, CONTEXT) #define metamacro_for_cxt15(MACRO, SEP, CONTEXT) \ metamacro_for_cxt14(MACRO, SEP, CONTEXT) \ SEP \ MACRO(14, CONTEXT) #define metamacro_for_cxt16(MACRO, SEP, CONTEXT) \ metamacro_for_cxt15(MACRO, SEP, CONTEXT) \ SEP \ MACRO(15, CONTEXT) #define metamacro_for_cxt17(MACRO, SEP, CONTEXT) \ metamacro_for_cxt16(MACRO, SEP, CONTEXT) \ SEP \ MACRO(16, CONTEXT) #define metamacro_for_cxt18(MACRO, SEP, CONTEXT) \ metamacro_for_cxt17(MACRO, SEP, CONTEXT) \ SEP \ MACRO(17, CONTEXT) #define metamacro_for_cxt19(MACRO, SEP, CONTEXT) \ metamacro_for_cxt18(MACRO, SEP, CONTEXT) \ SEP \ MACRO(18, CONTEXT) #define metamacro_for_cxt20(MACRO, SEP, CONTEXT) \ metamacro_for_cxt19(MACRO, SEP, CONTEXT) \ SEP \ MACRO(19, CONTEXT)
提取一下metamacro_for_cxtN的定义：
#define metamacro_for_cxtN(MACRO, SEP, CONTEXT) \ metamacro_for_cxtN - 1(MACRO, SEP, CONTEXT) \ SEP \ MACRO(N - 1, CONTEXT)
把metamacro_for_cxtN彻底展开以下：
MACRO(0, CONTEXT) \ SEP \ MACRO(1, CONTEXT) \ SEP \ MACRO(2, CONTEXT) \ SEP \ MACRO(3, CONTEXT) \ …… …… …… …… …… …… SEP \ MACRO(N - 4, CONTEXT) \ SEP \ MACRO(N - 3, CONTEXT) \ SEP \ MACRO(N - 2, CONTEXT) \ SEP \ MACRO(N - 1, CONTEXT)
这个宏的用途是执行COUNT次MACRO宏命令，每次MACRO宏命令的第一个参数都会从COUNT开始递减到0。
8. metamacro_head(...)
这个宏要求它的可变参数至少为1个。
#define metamacro_head(...) \ metamacro_head_(__VA_ARGS__, 0)
把宏展开，以下：
#define metamacro_head_(FIRST, ...) FIRST
metamacro_head(...) 的做用就是取出可变参数列表的第一个参数。
9. metamacro_tail(...)
这个宏要求它的可变参数至少为2个。
#define metamacro_tail(...) \ metamacro_tail_(__VA_ARGS__)
把宏展开，以下：
#define metamacro_tail_(FIRST, ...) __VA_ARGS__
metamacro_tail(...) 的做用就是取出可变参数列表除去第一个参数之外的全部参数。
10. metamacro_take(N, ...)
这个宏要求它的可变参数至少有N个。
#define metamacro_take(N, ...) \ metamacro_concat(metamacro_take, N)(__VA_ARGS__)
展开成以下的样子：
metamacro_takeN(__VA_ARGS__)
继续展开metamacro_takeN：
#define metamacro_take0(...) #define metamacro_take1(...) metamacro_head(__VA_ARGS__) #define metamacro_take2(...) metamacro_head(__VA_ARGS__), metamacro_take1(metamacro_tail(__VA_ARGS__)) #define metamacro_take3(...) metamacro_head(__VA_ARGS__), metamacro_take2(metamacro_tail(__VA_ARGS__)) #define metamacro_take4(...) metamacro_head(__VA_ARGS__), metamacro_take3(metamacro_tail(__VA_ARGS__)) #define metamacro_take5(...) metamacro_head(__VA_ARGS__), metamacro_take4(metamacro_tail(__VA_ARGS__)) #define metamacro_take6(...) metamacro_head(__VA_ARGS__), metamacro_take5(metamacro_tail(__VA_ARGS__)) #define metamacro_take7(...) metamacro_head(__VA_ARGS__), metamacro_take6(metamacro_tail(__VA_ARGS__)) #define metamacro_take8(...) metamacro_head(__VA_ARGS__), metamacro_take7(metamacro_tail(__VA_ARGS__)) #define metamacro_take9(...) metamacro_head(__VA_ARGS__), metamacro_take8(metamacro_tail(__VA_ARGS__)) #define metamacro_take10(...) metamacro_head(__VA_ARGS__), metamacro_take9(metamacro_tail(__VA_ARGS__)) #define metamacro_take11(...) metamacro_head(__VA_ARGS__), metamacro_take10(metamacro_tail(__VA_ARGS__)) #define metamacro_take12(...) metamacro_head(__VA_ARGS__), metamacro_take11(metamacro_tail(__VA_ARGS__)) #define metamacro_take13(...) metamacro_head(__VA_ARGS__), metamacro_take12(metamacro_tail(__VA_ARGS__)) #define metamacro_take14(...) metamacro_head(__VA_ARGS__), metamacro_take13(metamacro_tail(__VA_ARGS__)) #define metamacro_take15(...) metamacro_head(__VA_ARGS__), metamacro_take14(metamacro_tail(__VA_ARGS__)) #define metamacro_take16(...) metamacro_head(__VA_ARGS__), metamacro_take15(metamacro_tail(__VA_ARGS__)) #define metamacro_take17(...) metamacro_head(__VA_ARGS__), metamacro_take16(metamacro_tail(__VA_ARGS__)) #define metamacro_take18(...) metamacro_head(__VA_ARGS__), metamacro_take17(metamacro_tail(__VA_ARGS__)) #define metamacro_take19(...) metamacro_head(__VA_ARGS__), metamacro_take18(metamacro_tail(__VA_ARGS__)) #define metamacro_take20(...) metamacro_head(__VA_ARGS__), metamacro_take19(metamacro_tail(__VA_ARGS__))
这里也用到了递归的思想，每次取完头之后，剩下的队列针对于这次是tail，对于下次是head。因此每次都取head，以后再递归的取剩下部分的head，直到取出前N个数为止。
metamacro_take(N, ...)的做用就是取出可变参数的前N个数，并把它们组合成新的参数列表。
11. metamacro_drop(N, ...)
这个宏要求它的可变参数至少为N个。
#define metamacro_drop(N, ...) \ metamacro_concat(metamacro_drop, N)(__VA_ARGS__)
展开成以下的样子：
metamacro_dropN(__VA_ARGS__)
继续展开metamacro_dropN：
#define metamacro_drop0(...) __VA_ARGS__ #define metamacro_drop1(...) metamacro_tail(__VA_ARGS__) #define metamacro_drop2(...) metamacro_drop1(metamacro_tail(__VA_ARGS__)) #define metamacro_drop3(...) metamacro_drop2(metamacro_tail(__VA_ARGS__)) #define metamacro_drop4(...) metamacro_drop3(metamacro_tail(__VA_ARGS__)) #define metamacro_drop5(...) metamacro_drop4(metamacro_tail(__VA_ARGS__)) #define metamacro_drop6(...) metamacro_drop5(metamacro_tail(__VA_ARGS__)) #define metamacro_drop7(...) metamacro_drop6(metamacro_tail(__VA_ARGS__)) #define metamacro_drop8(...) metamacro_drop7(metamacro_tail(__VA_ARGS__)) #define metamacro_drop9(...) metamacro_drop8(metamacro_tail(__VA_ARGS__)) #define metamacro_drop10(...) metamacro_drop9(metamacro_tail(__VA_ARGS__)) #define metamacro_drop11(...) metamacro_drop10(metamacro_tail(__VA_ARGS__)) #define metamacro_drop12(...) metamacro_drop11(metamacro_tail(__VA_ARGS__)) #define metamacro_drop13(...) metamacro_drop12(metamacro_tail(__VA_ARGS__)) #define metamacro_drop14(...) metamacro_drop13(metamacro_tail(__VA_ARGS__)) #define metamacro_drop15(...) metamacro_drop14(metamacro_tail(__VA_ARGS__)) #define metamacro_drop16(...) metamacro_drop15(metamacro_tail(__VA_ARGS__)) #define metamacro_drop17(...) metamacro_drop16(metamacro_tail(__VA_ARGS__)) #define metamacro_drop18(...) metamacro_drop17(metamacro_tail(__VA_ARGS__)) #define metamacro_drop19(...) metamacro_drop18(metamacro_tail(__VA_ARGS__)) #define metamacro_drop20(...) metamacro_drop19(metamacro_tail(__VA_ARGS__))
这里也用到了递归的思想，每次都取当前队列的tail，每次都丢掉当前队列的head。这样递归N次就丢掉了前N位参数。
metamacro_drop(N, ...)的做用是丢掉当前参数列表里面的前N位参数。
12. metamacro_dec(VAL) 和 metamacro_inc(VAL)
这两个宏是一对。它们在元编程中，处理计数和index方面及其有用。VAL的值域都是[0,20]。
#define metamacro_dec(VAL) \ metamacro_at(VAL, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)
metamacro_dec(VAL) 提供了一个被左移一位的[0,20]的序列。那么经过metamacro_at计算出来的结果就比原来的结果小1。从而达到了减一的目的。
#define metamacro_inc(VAL) \ metamacro_at(VAL, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)
metamacro_inc(VAL) 提供了一个被右移一位的[0,20]的序列。那么经过metamacro_at计算出来的结果就比原来的结果大1。从而达到了加一的目的。
13. metamacro_if_eq(A, B)
首先A 和 B的值域都为[0,20]，而且B要大于等于A，即0<=A<=B<=20。
#define metamacro_if_eq(A, B) \ metamacro_concat(metamacro_if_eq, A)(B)
若是当A不等于0的时候，将上面的式子展开：
#define metamacro_if_eq(A, B) \ metamacro_if_eqA(B)
再继续把metamacro_if_eqA展开：
#define metamacro_if_eq1(VALUE) metamacro_if_eq0(metamacro_dec(VALUE)) #define metamacro_if_eq2(VALUE) metamacro_if_eq1(metamacro_dec(VALUE)) #define metamacro_if_eq3(VALUE) metamacro_if_eq2(metamacro_dec(VALUE)) #define metamacro_if_eq4(VALUE) metamacro_if_eq3(metamacro_dec(VALUE)) #define metamacro_if_eq5(VALUE) metamacro_if_eq4(metamacro_dec(VALUE)) #define metamacro_if_eq6(VALUE) metamacro_if_eq5(metamacro_dec(VALUE)) #define metamacro_if_eq7(VALUE) metamacro_if_eq6(metamacro_dec(VALUE)) #define metamacro_if_eq8(VALUE) metamacro_if_eq7(metamacro_dec(VALUE)) #define metamacro_if_eq9(VALUE) metamacro_if_eq8(metamacro_dec(VALUE)) #define metamacro_if_eq10(VALUE) metamacro_if_eq9(metamacro_dec(VALUE)) #define metamacro_if_eq11(VALUE) metamacro_if_eq10(metamacro_dec(VALUE)) #define metamacro_if_eq12(VALUE) metamacro_if_eq11(metamacro_dec(VALUE)) #define metamacro_if_eq13(VALUE) metamacro_if_eq12(metamacro_dec(VALUE)) #define metamacro_if_eq14(VALUE) metamacro_if_eq13(metamacro_dec(VALUE)) #define metamacro_if_eq15(VALUE) metamacro_if_eq14(metamacro_dec(VALUE)) #define metamacro_if_eq16(VALUE) metamacro_if_eq15(metamacro_dec(VALUE)) #define metamacro_if_eq17(VALUE) metamacro_if_eq16(metamacro_dec(VALUE)) #define metamacro_if_eq18(VALUE) metamacro_if_eq17(metamacro_dec(VALUE)) #define metamacro_if_eq19(VALUE) metamacro_if_eq18(metamacro_dec(VALUE)) #define metamacro_if_eq20(VALUE) metamacro_if_eq19(metamacro_dec(VALUE))
上面是一个递推的式子，最终确定会获得metamacro_if_eq0，最终的结果就是：
metamacro_if_eq0(B - A)
再把metamacro_if_eq0展开：
#define metamacro_if_eq0(VALUE) \ metamacro_concat(metamacro_if_eq0_, VALUE)
获得最终的展开式子：
metamacro_if_eq0_(B - A)
再查表获得最终结果：
#define metamacro_if_eq0_0(...) __VA_ARGS__ metamacro_consume_ #define metamacro_if_eq0_1(...) metamacro_expand_ #define metamacro_if_eq0_2(...) metamacro_expand_ #define metamacro_if_eq0_3(...) metamacro_expand_ #define metamacro_if_eq0_4(...) metamacro_expand_ #define metamacro_if_eq0_5(...) metamacro_expand_ #define metamacro_if_eq0_6(...) metamacro_expand_ #define metamacro_if_eq0_7(...) metamacro_expand_ #define metamacro_if_eq0_8(...) metamacro_expand_ #define metamacro_if_eq0_9(...) metamacro_expand_ #define metamacro_if_eq0_10(...) metamacro_expand_ #define metamacro_if_eq0_11(...) metamacro_expand_ #define metamacro_if_eq0_12(...) metamacro_expand_ #define metamacro_if_eq0_13(...) metamacro_expand_ #define metamacro_if_eq0_14(...) metamacro_expand_ #define metamacro_if_eq0_15(...) metamacro_expand_ #define metamacro_if_eq0_16(...) metamacro_expand_ #define metamacro_if_eq0_17(...) metamacro_expand_ #define metamacro_if_eq0_18(...) metamacro_expand_ #define metamacro_if_eq0_19(...) metamacro_expand_ #define metamacro_if_eq0_20(...) metamacro_expand_
上面这张表有两点注意点：
- 除了0_0，其余的都是metamacro_expand_。
#define metamacro_consume_(...) #define metamacro_expand_(...) __VA_ARGS__
除了0_0之外，其余全部操做都是直接透传参数，什么也不处理。metamacro_consume_(...)就是直接吞掉后续的参数。expand就是指的是能够继续展开宏，consume就是指的是终止展开宏，并吃掉后面的参数。
举2个例子：
// 第一个例子 metamacro_if_eq(0, 0)(true)(false) // 第二个例子 metamacro_if_eq(0, 1)(true)(false)
直接套用最终展开式：
// 第一个例子 metamacro_if_eq0_0(true)(false) // 第二个例子 metamacro_if_eq0_1(true)(false)
继续展开：
// 第一个例子 true metamacro_consume_(false) => true // 第二个例子 metamacro_expand_(false) => false
这个若是 B < A，那么(B - A) < 0，那么最终展开的式子就变成下面的样子：
metamacro_if_eq0_(负数)
这个宏展开到这个程度就无法继续下去了，就会出现编译错误。
14. metamacro_if_eq_recursive(A, B)
A 和 B的值域都为[0,20]，而且B要大于等于A，即0<=A<=B<=20。
定义以下：
#define metamacro_if_eq_recursive(A, B) \ metamacro_concat(metamacro_if_eq_recursive, A)(B)
展开以后：
metamacro_if_eq_recursiveA(B)
继续展开：
#define metamacro_if_eq_recursive1(VALUE) metamacro_if_eq_recursive0(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive2(VALUE) metamacro_if_eq_recursive1(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive3(VALUE) metamacro_if_eq_recursive2(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive4(VALUE) metamacro_if_eq_recursive3(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive5(VALUE) metamacro_if_eq_recursive4(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive6(VALUE) metamacro_if_eq_recursive5(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive7(VALUE) metamacro_if_eq_recursive6(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive8(VALUE) metamacro_if_eq_recursive7(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive9(VALUE) metamacro_if_eq_recursive8(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive10(VALUE) metamacro_if_eq_recursive9(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive11(VALUE) metamacro_if_eq_recursive10(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive12(VALUE) metamacro_if_eq_recursive11(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive13(VALUE) metamacro_if_eq_recursive12(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive14(VALUE) metamacro_if_eq_recursive13(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive15(VALUE) metamacro_if_eq_recursive14(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive16(VALUE) metamacro_if_eq_recursive15(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive17(VALUE) metamacro_if_eq_recursive16(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive18(VALUE) metamacro_if_eq_recursive17(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive19(VALUE) metamacro_if_eq_recursive18(metamacro_dec(VALUE)) #define metamacro_if_eq_recursive20(VALUE) metamacro_if_eq_recursive19(metamacro_dec(VALUE))
最终确定会获得metamacro_if_eq_recursive0_，最终的结果就是：
metamacro_if_eq_recursive0_(B - A)
再把metamacro_if_eq_recursive0_展开：
#define metamacro_if_eq_recursive0(VALUE) \ metamacro_concat(metamacro_if_eq_recursive0_, VALUE)
获得最终的式子：
metamacro_if_eq_recursive0_(B - A)
最终再比对下表：
#define metamacro_if_eq_recursive0_0(...) __VA_ARGS__ metamacro_consume_ #define metamacro_if_eq_recursive0_1(...) metamacro_expand_ #define metamacro_if_eq_recursive0_2(...) metamacro_expand_ #define metamacro_if_eq_recursive0_3(...) metamacro_expand_ #define metamacro_if_eq_recursive0_4(...) metamacro_expand_ #define metamacro_if_eq_recursive0_5(...) metamacro_expand_ #define metamacro_if_eq_recursive0_6(...) metamacro_expand_ #define metamacro_if_eq_recursive0_7(...) metamacro_expand_ #define metamacro_if_eq_recursive0_8(...) metamacro_expand_ #define metamacro_if_eq_recursive0_9(...) metamacro_expand_ #define metamacro_if_eq_recursive0_10(...) metamacro_expand_ #define metamacro_if_eq_recursive0_11(...) metamacro_expand_ #define metamacro_if_eq_recursive0_12(...) metamacro_expand_ #define metamacro_if_eq_recursive0_13(...) metamacro_expand_ #define metamacro_if_eq_recursive0_14(...) metamacro_expand_ #define metamacro_if_eq_recursive0_15(...) metamacro_expand_ #define metamacro_if_eq_recursive0_16(...) metamacro_expand_ #define metamacro_if_eq_recursive0_17(...) metamacro_expand_ #define metamacro_if_eq_recursive0_18(...) metamacro_expand_ #define metamacro_if_eq_recursive0_19(...) metamacro_expand_ #define metamacro_if_eq_recursive0_20(...) metamacro_expand_
接下来就和metamacro_if_eq(A, B)宏彻底同样了。
这个递归的宏也历来没有在RAC的其余宏中使用，做者在这里标注说明了这个宏的用处。
This can be used when the former would fail due to recursive macro expansion
因为宏在递归展开中可能会致使递归前置条件失败，在这种状况下，应该使用这个递归宏。固然，它的效果和metamacro_if_eq(A, B)宏是彻底同样的。
15. metamacro_is_even(N)
定义以下：
N的值域在[0,20]之间。
#define metamacro_is_even(N) \ metamacro_at(N, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1)
这个宏比较简单，就是判断N是否是偶数，下面metamacro_at把全部从0-20的天然数是偶数的都标志成了1，是奇数的都标志成了0。0在这里默认是偶数。
16. metamacro_not(B)
这里B的取值只能是0或者1。
#define metamacro_not(B) \ metamacro_at(B, 1, 0)
这个宏很简单，就是对参数逻辑取非运算。
三. ReactiveCocoa 中经常使用的宏
上一章节咱们分析完了ReactiveCocoa中全部的元宏，这一章节将会把元宏之外的宏的实现都分析一遍。包括咱们平常使用的常见的全部宏，它们看似神秘，可是他们都是由这些元宏来组成的。
1. weakify(...)、unsafeify(...)、strongify(...)
这三个在ReactiveCocoa必定是使用最多的，那么就先来分析这三个。这三个宏的定义在RACEXTScope.h中。
关于weakify(...)和strongify(...)，这两个宏的实现分析在以前的文章里面详细分析过了，详情能够看这篇文章《深刻研究Block用weakSelf、strongSelf、@weakify、@strongify解决循环引用》。
这里须要再次强调的一点是，在使用weakify(...)、unsafeify(...)、strongify(...)这三个宏的前面须要额外添加@符号。缘由是在这三个宏的实现里面都有rac_keywordify，它的实现以下：
#if DEBUG #define rac_keywordify autoreleasepool {} #else #define rac_keywordify try {} @catch (...) {} #endif
无论是在什么环境下，autoreleasepool {} 和 try {} @catch (...) {} 前面都要添加@符号，变成@autoreleasepool {} 和 @try {} @catch (...) {} 才能够继续使用。
既然@weakify(...)，@strongify(...)都分析过了，那么这里就分析一下@unsafeify(...)的实现。
#define unsafeify(...) \ rac_keywordify \ metamacro_foreach_cxt(rac_weakify_,, __unsafe_unretained, __VA_ARGS__)
rac_keywordify上面说过了，这里就直接展开metamacro_foreach_cxt宏。这里就套用以前元宏的分析，直接拿到最终展开表达式：
MACRO(0, CONTEXT, _0) \ SEP \ MACRO(1, CONTEXT, _1) \ SEP \ MACRO(2, CONTEXT, _2) \ SEP \ MACRO(3, CONTEXT, _3) \ …… …… …… …… …… …… SEP \ MACRO(N - 4, CONTEXT, _N - 4) \ SEP \ MACRO(N - 3, CONTEXT, _N - 3) \ SEP \ MACRO(N - 2, CONTEXT, _N - 2) \ SEP \ MACRO(N - 1, CONTEXT, _N - 1)
MACRO = rac_weakify_，SEP = 空格，CONTEXT = __unsafe_unretained。代入获得最终的展开式：
rac_weakify_(0, __unsafe_unretained, _0) \ rac_weakify_(1, __unsafe_unretained, _1) \ rac_weakify_(2, __unsafe_unretained, _2) \ rac_weakify_(3, __unsafe_unretained, _3) \ …… …… …… …… …… …… rac_weakify_(N - 4, __unsafe_unretained, _N - 4) \ rac_weakify_(N - 3, __unsafe_unretained, _N - 3) \ rac_weakify_(N - 2, __unsafe_unretained, _N - 2) \ rac_weakify_(N - 1, __unsafe_unretained, _N - 1)
把rac_weakify_再替换掉：
#define rac_weakify_(INDEX, CONTEXT, VAR) \ CONTEXT __typeof__(VAR) metamacro_concat(VAR, _weak_) = (VAR);
获得最终的展开表达式：
__unsafe_unretained __typeof__(_0) _0_weak_ = _0； __unsafe_unretained __typeof__(_1) _1_weak_ = _1； __unsafe_unretained __typeof__(_2) _2_weak_ = _2； …… …… …… …… …… …… __unsafe_unretained __typeof__(_N - 3) _N - 3_weak_ = _N - 3； __unsafe_unretained __typeof__(_N - 2) _N - 2_weak_ = _N - 2； __unsafe_unretained __typeof__(_N - 1) _N - 1_weak_ = _N - 1；
其中 _0， _1， _2 …… _N - 3， _N - 2， _N - 1是 __VA_ARGS__里面对应的是0 - N的参数值。
2. RACTuplePack(...) 和 RACTupleUnpack(...)
这两个在ReactiveCocoa中也是很是常见的宏，专门用在RACTuple中。
先看RACTuplePack(...)
#define RACTuplePack(...) \ RACTuplePack_(__VA_ARGS__)
再展开一步：
#define RACTuplePack_(...) \ ([RACTuple tupleWithObjectsFromArray:@[ metamacro_foreach(RACTuplePack_object_or_ractuplenil,, __VA_ARGS__) ]])
这里调用了RACTuple的tupleWithObjectsFromArray:方法。主要须要展开的是：
metamacro_foreach(RACTuplePack_object_or_ractuplenil,, __VA_ARGS__)
直接调用上一章节中metamacro_foreach的最终表达式：
MACRO(0, _0) \ SEP \ MACRO(1, _1) \ SEP \ MACRO(2, _2) \ SEP \ MACRO(3, _3) \ …… …… …… …… …… …… SEP \ MACRO(N - 4, _N - 4) \ SEP \ MACRO(N - 3, _N - 3) \ SEP \ MACRO(N - 2, _N - 2) \ SEP \ MACRO(N - 1, _N - 1)
MACRO = RACTuplePack_object_or_ractuplenil ， SEP = 空格，替换以后以下：
RACTuplePack_object_or_ractuplenil(0, _0) \ RACTuplePack_object_or_ractuplenil(1, _1) \ RACTuplePack_object_or_ractuplenil(2, _2) \ …… …… …… …… …… …… RACTuplePack_object_or_ractuplenil( N - 3, _N - 3) \ RACTuplePack_object_or_ractuplenil( N - 2, _N - 2) \ RACTuplePack_object_or_ractuplenil( N - 1, _N - 1)
最后一步就是替换掉RACTuplePack_object_or_ractuplenil：
#define RACTuplePack_object_or_ractuplenil(INDEX, ARG) \ (ARG) ?: RACTupleNil.tupleNil,
注意这里宏结尾是“，”逗号，而不是“；”分号，缘由是由于tupleWithObjectsFromArray:方法里面是各个元素，因此这里用“；”分号就会出错，反而应该用“，”逗号，可见设计宏的时候须要考虑清楚使用场景，不能乱写。
展开上面最后一层宏以后，原可变参数列表里面的全部非nil的值就都排列到了tupleWithObjectsFromArray:方法里面了，若是是nil的，就会变成RACTupleNil.tupleNil放进Array里面。
再来看看RACTupleUnpack(...)
#define RACTupleUnpack(...) \ RACTupleUnpack_(__VA_ARGS__)
再展开一步：
#define RACTupleUnpack_(...) \ metamacro_foreach(RACTupleUnpack_decl,, __VA_ARGS__) \ \ int RACTupleUnpack_state = 0; \ \ RACTupleUnpack_after: \ ; \ metamacro_foreach(RACTupleUnpack_assign,, __VA_ARGS__) \ if (RACTupleUnpack_state != 0) RACTupleUnpack_state = 2; \ \ while (RACTupleUnpack_state != 2) \ if (RACTupleUnpack_state == 1) { \ goto RACTupleUnpack_after; \ } else \ for (; RACTupleUnpack_state != 1; RACTupleUnpack_state = 1) \ [RACTupleUnpackingTrampoline trampoline][ @[ metamacro_foreach(RACTupleUnpack_value,, __VA_ARGS__) ] ]
乍一看这个宏像一段程序，仔细分析一下也不难。RACTupleUnpack_state 就是一个局部变量，表明状态的。RACTupleUnpack_after: 这是一个标号，用来给goto跳转使用的。
// 1 metamacro_foreach(RACTupleUnpack_decl,, __VA_ARGS__) // 2 metamacro_foreach(RACTupleUnpack_assign,, __VA_ARGS__) // 3 metamacro_foreach(RACTupleUnpack_value,, __VA_ARGS__)
这里面须要展开的就是这3个宏了。
套用上一章节中metamacro_foreach的最终表达式，直接把MACRO分别为 RACTupleUnpack_decl，RACTupleUnpack_assign，RACTupleUnpack_value 代入表达式。
// 1 RACTupleUnpack_decl(0, _0) \ …… …… …… RACTupleUnpack_decl( N - 1, _N - 1) // 2 RACTupleUnpack_assign(0, _0) \ …… …… …… RACTupleUnpack_assign( N - 1, _N - 1) // 3 RACTupleUnpack_value(0, _0) \ …… …… …… RACTupleUnpack_value( N - 1, _N - 1)
分别替换掉这3个宏：
#define RACTupleUnpack_decl(INDEX, ARG) \ __strong id RACTupleUnpack_decl_name(INDEX); #define RACTupleUnpack_assign(INDEX, ARG) \ __strong ARG = RACTupleUnpack_decl_name(INDEX); #define RACTupleUnpack_value(INDEX, ARG) \ [NSValue valueWithPointer:&RACTupleUnpack_decl_name(INDEX)],
发现这3个宏都是用RACTupleUnpack_decl_name实现的。
#define RACTupleUnpack_decl_name(INDEX) \ metamacro_concat(metamacro_concat(RACTupleUnpack, __LINE__), metamacro_concat(_var, INDEX))
这个展开就是一个名字：
RACTupleUnpack __LINE__ _varINDEX
以后的实现，请看《ReactiveCocoa 中 集合类RACSequence 和 RACTuple底层实现分析》这篇文章的详细分析。
3. RACObserve(TARGET, KEYPATH)
定义以下：
#define RACObserve(TARGET, KEYPATH) \ ({ \ _Pragma("clang diagnostic push") \ _Pragma("clang diagnostic ignored \"-Wreceiver-is-weak\"") \ __weak id target_ = (TARGET); \ [target_ rac_valuesForKeyPath:@keypath(TARGET, KEYPATH) observer:self]; \ _Pragma("clang diagnostic pop") \ })
看完定义，RACObserve(TARGET, KEYPATH) 实质其实就是调用了rac_valuesForKeyPath:方法。这个方法是NSObject的一个category，因此只要是NSObject就能够调用这个方法。因此这里的关键就是要分析清楚@keypath(TARGET, KEYPATH) 这个宏的实现。
如下重点分析一下keypath(...)的实现
#define keypath(...) \ metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__))(keypath1(__VA_ARGS__))(keypath2(__VA_ARGS__)) #define keypath1(PATH) \ (((void)(NO && ((void)PATH, NO)), strchr(# PATH, '.') + 1)) #define keypath2(OBJ, PATH) \ (((void)(NO && ((void)OBJ.PATH, NO)), # PATH))
metamacro_argcount这个宏在元宏里面分析过，是取出可变参数个数的。metamacro_if_eq也详细分析过，是判断里面2个参数是否至关的。因此keypath(...)整体展开的意思是说，可变参数的个数是否等于1，若是等于1，就执行(keypath1(__VA_ARGS__))，若是不等于1，就执行(keypath2(__VA_ARGS__))。
这里有几点须要说明的：
1.加void是为了防止逗号表达式的warning。例如：
int a=0; int b = 1; int c = (a,b);
因为a没有被用到，因此会有警告。可是写成以下的样子就不会出现警告了：
int c = ((void)a,b);
因此上面keypath1和keypath2加了几个void就是为了防止出现warning。
2.加NO是C语言判断条件短路表达式。增长NO && 之后，预编译的时候看见了NO，就会很快的跳过判断条件。
3.strchr函数原型以下：
extern char *strchr(const char *s,char c);
查找字符串s中首次出现字符c的位置。返回首次出现字符c的位置的指针，返回的地址是被查找字符串指针开始的第一个与字符c相同字符的指针，若是字符串中不存在字符c则返回NULL。
4.当输入self.的时候，会出现编译器的语法提示，缘由是OBJ.PATH，由于这里的点，因此输入第二个参数时编辑器会给出正确的代码提示。
5.使用keypath(...)的时候前面会加上@符号，缘由是通过keypath1(PATH)和keypath2(OBJ, PATH)以后出现的结果是一个C的字符串，前面加上@之后，就变成了OC的字符串了。
举3个例子
// 例子1，一个参数的状况，会调用keypath1(PATH) NSString *UTF8StringPath = @keypath(str.lowercaseString.UTF8String); // 输出=> @"lowercaseString.UTF8String" // 例子2，2个参数的状况，支持自省 NSString *versionPath = @keypath(NSObject, version); // 输出=> @"version" // 例子3，2个参数的状况 NSString *lowercaseStringPath = @keypath(NSString.new, lowercaseString); // 输出=> @"lowercaseString"
相应的也有集合类的keypath
#define collectionKeypath(...) \ metamacro_if_eq(3, metamacro_argcount(__VA_ARGS__))(collectionKeypath3(__VA_ARGS__))(collectionKeypath4(__VA_ARGS__)) #define collectionKeypath3(PATH, COLLECTION_OBJECT, COLLECTION_PATH) ([[NSString stringWithFormat:@"%s.%s",keypath(PATH), keypath(COLLECTION_OBJECT, COLLECTION_PATH)] UTF8String]) #define collectionKeypath4(OBJ, PATH, COLLECTION_OBJECT, COLLECTION_PATH) ([[NSString stringWithFormat:@"%s.%s",keypath(OBJ, PATH), keypath(COLLECTION_OBJECT, COLLECTION_PATH)] UTF8String])
原理也是调用了keypath(PATH)，原理这里就再也不赘述了。
4. RAC(TARGET, ...)
宏定义以下：
#define RAC(TARGET, ...) \ metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \ (RAC_(TARGET, __VA_ARGS__, nil)) \ (RAC_(TARGET, __VA_ARGS__))
RAC(TARGET, ...) 和上一个RACObserve(TARGET, KEYPATH)原理相似。若是只有一个参数就调用(RAC_(TARGET, __VA_ARGS__, nil))，若是是多个参数就调用(RAC_(TARGET, __VA_ARGS__))。
#define RAC_(TARGET, KEYPATH, NILVALUE) \ [[RACSubscriptingAssignmentTrampoline alloc] initWithTarget:(TARGET) nilValue:(NILVALUE)][@keypath(TARGET, KEYPATH)]
到这里就很明了了，其实内部就是调用RACSubscriptingAssignmentTrampoline类的initWithTarget: nilValue:方法。
咱们都知道RAC(TARGET, ...)宏是用来把一个信号绑定给一个对象的属性，绑定以后，每次信号发送出一个新的值，就会自动设定到执行的keypath中。当信号完成以后，此次绑定也会自动的解除。
RAC_(TARGET, KEYPATH, NILVALUE) 会把信号绑定到TARGET指定的KEYPATH上。若是信号发送了nil的值，那么会替换成NILVALUE赋值给对应的属性值上。
RAC_(TARGET, __VA_ARGS__)只不过是RAC_(TARGET, KEYPATH, NILVALUE)第三个参数为nil。
5. RACChannelTo(TARGET, ...)
RACChannelTo(TARGET, ...)这个宏彻底能够类比RAC(TARGET, ...)，两个几乎彻底同样。
#define RACChannelTo(TARGET, ...) \ metamacro_if_eq(1, metamacro_argcount(__VA_ARGS__)) \ (RACChannelTo_(TARGET, __VA_ARGS__, nil)) \ (RACChannelTo_(TARGET, __VA_ARGS__))
若是只有一个参数就调用(RACChannelTo_(TARGET, __VA_ARGS__, nil)) ，若是是多个参数就调用(RACChannelTo_(TARGET, __VA_ARGS__))。(RACChannelTo_(TARGET, __VA_ARGS__))至关因而(RACChannelTo_(TARGET, __VA_ARGS__, nil)) 第三个参数传了nil。
#define RACChannelTo_(TARGET, KEYPATH, NILVALUE) \ [[RACKVOChannel alloc] initWithTarget:(TARGET) keyPath:@keypath(TARGET, KEYPATH) nilValue:(NILVALUE)][@keypath(RACKVOChannel.new, followingTerminal)]
最终内部是调用了RACKVOChannel的initWithTarget: keyPath: nilValue:方法。具体原理能够彻底类比RAC(TARGET, ...)宏展开，这里再也不赘述。
平时咱们都是这样用：
RACChannelTo(view, objectProperty) = RACChannelTo(model, objectProperty);
RACChannelTo(view, integerProperty, @2) = RACChannelTo(model, integerProperty, @10);
6. onExit
宏定义以下：
#define onExit \ rac_keywordify \ __strong rac_cleanupBlock_t metamacro_concat(rac_exitBlock_, __LINE__) __attribute__((cleanup(rac_executeCleanupBlock), unused)) = ^
因为rac_keywordify的存在，因此在使用onExit的时候，前面也要加上@符号。
这个宏比较特殊，最后是跟着一个闭包，好比这样：
@onExit {
free(attributes);
};
@onExit {
[objectLock unlock];
};
@onExit定义当前代码段退出时要执行的一些代码。代码必须用大括号括起来并以分号结尾，不管是何种状况（包括出现异常，goto语句，return语句，break语句，continue语句）下跳出代码段，都会执行onExit后面的代码。
@onExit提供的代码被放进一个block块中，以后才会执行。由于在闭包中，因此它也必须遵循内存管理方面的规则。@onExit是以一种合理的方式提早退出清理块。
在相同代码段中若是有多个@onExit语句，那么他们是按照反字典序的顺序执行的。
@onExit语句不能在没有大括号的范围内使用。在实际使用过程当中，这不是一个问题，由于@onExit后面若是没有大括号，那么它是一个无用的结构，不会有任何事情发生。
最后
关于ReactiveCocoa里面全部宏的实现分析都已经分析完成。我以为宏是对一段逻辑的高度抽象，当一个宏被思惟完备的开发人员设计出来之后，就是一个充满神奇色彩的魔法！若是能把一些简单实用的功能或者逻辑抽象成宏，把这些时间都节约到预编译中，节约运行时的时间，单从编码的程度来讲，都是极有乐趣的一件事情！若是之后有机会，但愿还能和你们交流交流Lisp里面的相关宏魔法的知识。