面向组合子
面向组合子(Combanitor-Oriented)，是最近帮我打开新世界大门的一种pattern。缘起haskell，又见monad与ParseC，终于ajoo前辈的几篇文章。
自去年9月起正式回归C#以来，我又逐渐接受了不少新的paradigm(虽然主要原因还是在学校用C#的方法太山寨)，其中对我影响比较深刻的就是codegen。此codegen非compiler中的codegen，可能更像是meta-programming中的codegen。抽象来说，就是作为一个嵌入于构建流程中的某一步骤，拿到一些元描述信息，来生成代码。
我目前所接触到的codegen的具体应用情景，有这样几种：
1.RPC相关的，数据打解包逻辑、Stub/Skeleton、组播等
2.配表转代码
3.策划配出来的可视化行为树转代码
从这些情景可以看出这种需求的典型特征：性能好、便于上层调用。
具体来说，我们还是拿这种形式跟一些比较传统的形式做下对比：
RPC打解包逻辑直接自动走函数 V.S. protobuf
codegen成C#代码的行为树 V.S. 硬解脚本
C#结构描述的配置 V.S. 一坨meta二进制+一坨data二进制
又是一堆废话，现在直接进入主题。
正文
首先定义一个概念，Coder，当然这跟平时一些低端讨论串上经常引起的Coder还是Programmer中的Coder没关系，这里我们把它理解为一个函数，接收一个T描述结构作为参数，输出一个字符串。
为了更C#一点，我们这样定义Coder：
public interface ICoder<in T> { string Code(T meta); }
这是所有Coder的基本表现形式，与之对应的，任何复杂的代码生成程序，其实本质都是通过一个抽象数据结构生成一个字符串。
基于ICoder，我们先从最简单的组合子开始构造，也就是"0"和"1"：
internal class UnitCoder<T> : ICoder<T> { readonly string output; public UnitCoder(string output) { this.output = output; } public override string Code(T meta) { return output; } } internal class ZeroCoder<T> : ICoder<T> { private static ZeroCoder<T> instance; public static ZeroCoder<T> Instance { get { return instance ?? (instance = new ZeroCoder<T>()); } } public override string Code(T meta) { return ""; } }
UnitCoder：不论给什么作为输入，都只返回一个固定的字符串
ZeroCoder：不论给什么作为输入，都返回空字符串
只有这两个的话，似乎还是什么都不能做，我们需要一个最基本的可以让我们定制的Coder：
internal class BasicCoder<T> : ICoder<T> { private readonly Func<T, string> func; public BasicCoder(Func<T, string> func) { this.func = func; } public override string Code(T meta) { return func(meta); } }
假设现在有一个结构定义：
class Meta1 { public string Type; public string Name; public string Value; }
如此构造一个BasicCoder：
var basicCoder = Generator.GenBasic((Meta1 m) => string.Format(@"{0} {1} = {2}", m.Type, m.Name, m.Value));
这样，通过给basicCoder传不同的、具体的Meta1实例，这个Coder就跟真的Coder一样coding出了不一样的代码。
仅有这三个还不够，我们还需要想一种办法将两个Coder组合起来。说实话，这一块代码我写得非常丑，整理成博客的原因也是希望有哪位前辈看到能指点一下。好了，直接上有很明显bad smell的代码。
首先需要对最基本的ICoder结构进行改造：
public interface ICoder { string Code(object meta); } public interface ICoder<in T> : ICoder { string Code(T meta); }
这样ICoder来提供通用的Coder接口，方便后面的SequenceCoder。所有的Coder都复用一下这样的逻辑：
internal abstract class CoderBase<T> : ICoder<T> { private readonly T instance; public abstract string Code(T meta); public string Code(object meta) { if (meta is T) { return Code((T)meta); } throw new Exception("..."); } }
然后我们着手实现SequenceCoder：
internal class SequenceCoder<T> : CoderBase<T> { readonly ICoder[] coderArr; readonly Func<T, ICoder[], string> coderJoiner; public SequenceCoder(ICoder[] coderArr, Func<T, ICoder[], string> coderJoiner) { this.coderArr = coderArr; this.coderJoiner = coderJoiner; } public override string Code(T meta) { return coderJoiner(meta, coderArr); } }
我对SequenceCoder的定位是，Coder组合子系统内部的一个结合不同Coder的基础组件。
有了SequenceCoder，我们就可以多出来很多有意义的东西了。
之前我们构造的basicCoder，是没打出来语句末尾的";"的，我们来构造一下。先是前后缀的一些公共逻辑：
internal static ICoder<T> WithPostfix<T>(this ICoder<T> coder, string postfix) { var coderPostfix = new UnitCoder<T>(postfix); return new SequenceCoder<T>(new ICoder[] { coder, coderPostfix }, (meta, arr) => string.Join("", coder.Code(meta), coderPostfix.Code(meta))); } internal static ICoder<T> WithPrefix<T>(this ICoder<T> coder, string prefix) where { var coderPrefix = new UnitCoder<T>(prefix); return new SequenceCoder<T>(new ICoder[] { coderPrefix, coder }, (meta, arr) => string.Join("", coderPrefix.Code(meta), coder.Code(meta))); }
然后是statementCoder：
var statementCoder = basicCoder.WithPostfix(";");
还可以被大括号包裹：
public static ICoder<T> Brace<T>(this ICoder<T> coder) { return coder.WithPostfix("}").WithPrefix("{"); }
var braceStatementCoder = statementCoder.Brace();
可以实现重复，也就是将一个ICoder<T>转为一个ICoder<IEnumerable<T>>：
internal class RepeatedCoder<T> : CoderBase<IEnumerable<T>> { private readonly ICoder coder; private readonly string seperator; private readonly Func<T, bool> predicate; public RepeatedCoder(ICoder<T> coder, string seperator, Func<T, bool> predicate) { this.coder = coder; this.seperator = seperator; this.predicate = predicate; } public override string Code(IEnumerable<T> meta) { bool first = true; return meta.Where(m=>predicate(m)).Select(m => coder.Code(m)).Aggregate("", (val, cur) => { if (first) { first = false; return val + cur; } return val + seperator + cur; }); } }
为了自己写代码方便，直接把seperator和predicate逻辑硬塞进去了，各位看官见谅。
构造一个重复Coder：
public static ICoder<IEnumerable<T>> Many<T>(this ICoder<T> coder, string seperator) where T : class { return Generator.GenRepeated(coder, seperator); }
var repeatedCoder = basicCoder.WithPostfix(";").Many("\n");
这样，给repeatedCoder一个Meta1的数组，他就会像一只coder一样自动把每个元素转成一行代码。
有了这些还不够，我们还是回归需求本身。假设有这样一个Coder :: ICoder<A>，这个Coder需要根据A的某个字段比如name写出来一个 class name，需要根据另外一个比如IEnumerable<B>类型的字段写出一系列field的定义。
我们期望生成的代码形式：
class XXX{ public t1 aaa = v1; public t2 bbb = v2;}
假设A的结构定义是这样的：
class A{ public string Name; public IEnumerable<Meta1> Fields;}
其实这种需求也是我做出之前那种坏味代码的原因，还是那句话，求高人指点！继续上代码，CombineCoder：
public static ICoder<T> GenCombine<T, T1>(ICoder<T> tCoder, ICoder<T1> t1Coder, Func<T, T1> selector) { return new SequenceCoder<T>(new ICoder[] { tCoder, t1Coder }, (meta, arr) => string.Format("{0}{1}", tCoder.Code(meta), t1Coder.Code(selector(meta)))); }
复用我们之前构造的repeatedCoder
var coder1 = Generator.GenBasic((A a) => string.Format("class {0}", a.Name)).WithPostfix("\n");var coder2 = repeatedCoder.Brace();
现在我们希望一个A->string的coder1与一个IEnumerable<Meta1>->string的coder2 combine起来，组合成一个A->string的classCoder，这样做：
var classCoder = Generator.GenCombine(coder1, coder2, a => a.Fields);
好了大功告成，给classCoder一个A类型的元数据实例，就能输出我们期望的字符串。
写在最后
这篇博文的主体内容其实也差不多告一段落了。诚然，以上贴出的代码不论是性能还是扩展性都存在很大的问题，但是前者对于一个codegen程序来说并不是关键考虑因素；而后者，正如之前所说，代码的坏味还是存在不少，不仅在于SequenceCoder，也在于Combine，正因为这两个目前的设计形式，导致了ICoder与ICoder<T>的坏味。
Sequence与Combine其实是相同的一种需求，如果将一个Coder看作一个monad的话，如何用一种可以理解的概念表示monad a与monad b的运算？我之前的确有尝试过对bind进行生搬硬套，可是无论如何都不如目前实现的Combine方便，于是就产生了写这篇小品文的念头，期望高人解答。
因为是小品文，所以也没像之前的消息队列那篇一样用了那么多精力。本来2月份一直在看haskell和Parsec，打算写一篇关于parsec跟行为树的东西，结果后来因为一些事情搁置了。。只能之后再说了。
面向组合子的这种方式，除开我整篇文章提到的codegen，其实在游戏逻辑实现中还是不太常见的。我第一次见到是在我们工作室自研的行为树引擎中，中间语言翻译到特定语言(C#)，用运行时库中实现好的一些组合子组合起来成为一整棵行为树。