面向组合子设计Coder

面向组合子

面向组合子(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. protobufcodegen成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程序来说并不是关键考虑因素；而后者，正如之前所说，代码的坏味还是存在不