面向组合子设计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. 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#)，用运行时库中实现好的一些组合子组合起来成为一整棵行为树。