问使用Dhall将递归类型编码为JSON
EN

Stack Overflow用户

提问于 2021-07-21 14:39:25

回答 1查看 59关注 0票数 1

我想要的输出的简化版本：

{
  "dynamic-name": {
    "type": "type",
    "fields": {
      "inner-dynamic-name": {
        "type": "inner-type",
        "analyzer": "analyzer"
      }
    }
  }
}

下面是我用来生成它的Dhall代码：

let Field
    : Type
    = ∀(Field : Type) →
      ∀ ( Leaf
        : { mapKey : Text, mapValue : { type : Text, analyzer : Optional Text } } →
            Field
        ) →
      ∀ ( Node
        : { mapKey : Text, mapValue : { type : Text, fields : List Field } } →
            Field
        ) →
        Field

let example
    : Field
    = λ(Field : Type) →
      λ ( Leaf
        : { mapKey : Text, mapValue : { type : Text, analyzer : Optional Text } } →
            Field
        ) →
      λ ( Node
        : { mapKey : Text, mapValue : { type : Text, fields : List Field } } →
            Field
        ) →
        Node
          { mapKey = "dynamic-name"
          , mapValue =
            { type = "type"
            , fields =
              [ Leaf
                  { mapKey = "inner-dynamic-name"
                  , mapValue =
                    { type = "inner-type", analyzer = Some "analyzer" }
                  }
              ]
            }
          }

in  example

但是，在将我的Dhall配置传递给dhall-to-json时，我得到以下错误：

Error: Cannot translate to JSON                                            
                                                                                
Explanation: Only primitive values, records, unions, ❰List❱s, and ❰Optional❱    
values can be translated from Dhall to JSON                                     
                                                                                
The following Dhall expression could not be translated to JSON:                 
                                                                                
↳ λ(_ : Type) →
  λ ( _
    : { mapKey : Text, mapValue : { analyzer : Optional Text, type : Text } } →
        _@1
    ) →
  λ(_ : { mapKey : Text, mapValue : { fields : List _@1, type : Text } } → _@2) →
    _
      { mapKey = "dynamic-name"
      , mapValue =
        { fields =
          [ _@1
              { mapKey = "inner-dynamic-name"
              , mapValue = { analyzer = Some "analyzer", type = "inner-type" }
              }
          ]
        , type = "type"
        }
      }

我运行的是1.7.6版的dhall-to-json。我做错了什么？

(忽略:我需要包含更多的单词才能允许发布我的问题，但任何更多的内容似乎都是多余的。最后一句话是我是黑客。)

dhall

回答 1

Stack Overflow用户

回答已采纳

发布于 2021-07-22 17:30:05

我将我的答案从https://github.com/dhall-lang/dhall-haskell/issues/2259复制到这里：

dhall-to-json不能直接处理自定义递归类型，但它可以处理一种可区分的递归类型，即Prelude.JSON.Type，所以下面这样的代码就可以工作了：

let JSON =
      https://prelude.dhall-lang.org/JSON/package.dhall
        sha256:5f98b7722fd13509ef448b075e02b9ff98312ae7a406cf53ed25012dbc9990ac

let Field
    : Type
    = ∀(Field : Type) →
      ∀ ( Leaf
        : { mapKey : Text
          , mapValue : { type : Text, analyzer : Optional Text }
          } →
            Field
        ) →
      ∀ ( Node
        : { mapKey : Text, mapValue : { type : Text, fields : List Field } } →
            Field
        ) →
        Field

let example
    : Field
    = λ(Field : Type) →
      λ ( Leaf
        : { mapKey : Text
          , mapValue : { type : Text, analyzer : Optional Text }
          } →
            Field
        ) →
      λ ( Node
        : { mapKey : Text, mapValue : { type : Text, fields : List Field } } →
            Field
        ) →
        Node
          { mapKey = "dynamic-name"
          , mapValue =
            { type = "type"
            , fields =
              [ Leaf
                  { mapKey = "inner-dynamic-name"
                  , mapValue =
                    { type = "inner-type", analyzer = Some "analyzer" }
                  }
              ]
            }
          }

let Field/toJSON
    : Field → JSON.Type
    = λ(field : Field) →
        field
          JSON.Type
          ( λ ( args
              : { mapKey : Text
                , mapValue : { type : Text, analyzer : Optional Text }
                }
              ) →
              JSON.object
                [ { mapKey = args.mapKey
                  , mapValue =
                      JSON.object
                        ( toMap
                            { type = JSON.string args.mapValue.type
                            , analyzer =
                                merge
                                  { None = JSON.null, Some = JSON.string }
                                  args.mapValue.analyzer
                            }
                        )
                  }
                ]
          )
          ( λ ( args
              : { mapKey : Text
                , mapValue : { type : Text, fields : List JSON.Type }
                }
              ) →
              JSON.object
                [ { mapKey = args.mapKey
                  , mapValue =
                      JSON.object
                        ( toMap
                            { type = JSON.string args.mapValue.type
                            , fields = JSON.array args.mapValue.fields
                            }
                        )
                  }
                ]
          )

in  Field/toJSON example

…而dhall-to-json接受这一点：

$ dhall-to-json --file ./example.dhall

{
  "dynamic-name": {
    "fields": [
      {
        "inner-dynamic-name": {
          "analyzer": "analyzer",
          "type": "inner-type"
        }
      }
    ],
    "type": "type"
  }
}