コード例 #1
0
        private void AddToStringFun(Type type)
        {
            if (!type.IsEnum)
            {
                return;
            }

            var funName = ToStringFunName(type);

            if (FunDefs.ContainsKey(funName))
            {
                return;
            }

            var caseExp = new CaseExp(new Id("v"));

            foreach (var alt in type.GetEnumNames())
            {
                caseExp.Cases.Add(new Tuple <ElmAstNode, ElmAstNode>(
                                      new Id(AdtAlternativeName(type, alt)),
                                      new StringLiteral(alt)
                                      ));
            }

            var fun = new FunDef(funName, $"{funName} : {type.Name} -> {Elm.Types.STRING}");

            fun.Params.Add("v");
            fun.Body = caseExp;

            FunDefs.Add(funName, fun);
        }
コード例 #2
0
        public void AddDecodeFun(Type type)
        {
            var funName = DecodeFunName(type);

            if (FunDefs.ContainsKey(funName))
            {
                return;
            }

            var f = new FunDef(funName, $"{funName} : {Elm.Types.DECODER} {type.Name}");

            if (type.IsEnum)
            {
                var innerFunName = $"{funName}Value";
                if (FunDefs.ContainsKey(innerFunName))
                {
                    return;
                }


                var innerF = new FunDef(innerFunName, $"{innerFunName} : {Elm.Types.STRING} -> {Elm.Types.DECODER} {type.Name}");
                innerF.Params.Add("s");

                var caseExp = new CaseExp(new Id("s"));
                innerF.Body = caseExp;
                foreach (var alt in type.GetEnumNames())
                {
                    caseExp.Cases.Add(new Tuple <ElmAstNode, ElmAstNode>(
                                          new StringLiteral(alt),
                                          new FunApp(new Id("Decode.succeed"))
                    {
                        Rands = { new Id(AdtAlternativeName(type, alt)) }
                    }));
                }

                caseExp.Cases.Add(new Tuple <ElmAstNode, ElmAstNode>(
                                      new Id("_"),
                                      new FunApp(new Id("Decode.fail"))
                {
                    Rands = { new Id("(\"Unknown value: \" ++ s)") }
                }));

                FunDefs.Add(innerFunName, innerF);

                //Outer fun
                f.Body = new PipelineExpr()
                {
                    Exprs =
                    {
                        new Id(Elm.Decoders.STRING),
                        new FunApp(new Id(Elm.Decoders.ANDTHEN))
                        {
                            Rands = { new Id(innerFunName) }
                        }
                    }
                };
            }
            else
            {
                var pipeline = new PipelineExpr();
                pipeline.Exprs.Add(new FunApp(new Id("Decode.succeed"))
                {
                    Rands = { new Id(type.Name) }
                });
                foreach (var prop in type.GetProperties(PROP_FLAGS))
                {
                    var jsonAttrs = prop.GetCustomAttributes(typeof(JsonPropertyAttribute));
                    var jsonAttr  = jsonAttrs.FirstOrDefault() as JsonPropertyAttribute;
                    if (null != jsonAttr)
                    {
                        var jsonFieldName = jsonAttr.PropertyName ?? SnakeCase(prop.Name);
                        pipeline.Exprs.Add(new FunApp(new Id("required"))
                        {
                            Rands = { new StringLiteral(jsonFieldName), new Id(DecodeFunName(prop.PropertyType)) }
                        });
                    }
                }

                f.Body = pipeline;
            }

            FunDefs.Add(funName, f);
        }