在 Typed Racket 中转换为任意类型折叠树

Question

我正在尝试生成一个类型化的 Racket 过程，该过程对于某些类型 A，采用 Tree，以及从两个 As 到 A 的函数，另一个类型为 A 的参数，并返回一个A 类型的值。我对(All) 语法不是很熟悉，但我尝试过使用它。不幸的是，我的代码在构建时产生了以下错误消息：

Type Checker: Polymorphic function `foldr' could not be applied to arguments:
Types: (-> a b b) b (Listof a)  -> b
       (-> a b c c) c (Listof a) (Listof b)  -> c
       (-> a b c d d) d (Listof a) (Listof b) (Listof c)  -> d
Arguments: (-> A A A) A (Listof Any)
Expected result: A

我的代码：

(: fold : (All (A) (Instance Tree) (A A -> A) A -> A))
(define (fold tree f base)
  (foldr
    f
    base
    (cons
      (value tree)
      (map 
        (lambda
          ([tree : (Instance Tree)])
          (fold tree f base)
          ) 
        (children tree)
        )
      )
    )
  )

我试图简化函数直到它开始工作，这就是它开始工作的地方：

(: fold : (All (A) (Instance Tree) (A A -> A) A -> A))
(define (fold tree f base)
  (foldr f base (list base))
)

我认为正在发生的事情是类型检查器不知道(value tree) 也是A 类型。有什么办法可以让(Cast) 成为A 类型？如果没有，我将如何实现它？

Answer 1

没有Tree 类型的定义很难回答这个问题。但一般来说，答案不是强制转换，而是拥有一种类型，即具有某种类型的 of 节点的树。我不了解 Racket 中的类，尤其是它们与类型化 Racket 的交互（这似乎都可能发生变化），但这里是你如何使用structs 来做到这一点的，它们在类型化 Racket 中得到了很好的支持：

(struct (A) tree
  ((value : A)
   (children : (Listof (Treeof A))))
  #:type-name Treeof)

现在我可以检查一下：

> (tree 1 (list (tree -1 '())))
- : (Treeof (U Negative-Fixnum One))
#<tree>
> (tree 1 (list (tree 'x '())))
- : (Treeof (U 'x One))
#<tree>

好的，它计算出来的类型有点无用，但它们是正确的。

一旦你这样做了，它就会知道tree-value和tree-children的好处：

> tree-value
- : (All (A) (-> (Treeof A) A))
#<procedure:tree-value>
> tree-children
- : (All (A) (-> (Treeof A) (Listof (Treeof A))))
#<procedure:tree-children>

这足以编写你的函数（我不确定它是否正确，但它的类型现在有意义）：

(: fold-tree (All (A) (-> (Treeof A) (-> A A A) A A)))
(define (fold-tree tree f base)
  (foldr f base
         (cons
          (tree-value tree)
          ;; I don't know why it needs this since it knows about tree-children
          (map (λ ((child : (Treeof A)))
                 (fold-tree child f base))
               (tree-children tree)))))

请注意，由于某种原因，它无法确定(map (λ (child) ...) (tree-children tree)) 中的child 是(Treeof A)，即使它知道tree 是并且它知道tree-children 做了什么。所以我不得不告诉它（旧版本有问题，使用tree而不是child，隐藏了这个问题。

Answer 2

使用the answer by tfb 中的结构类型定义，

#lang typed/racket

(struct (A) tree
  ((value : A)
   (children : (Listof (Treeof A))))
  #:type-name Treeof)

以下定义有效（有点）：

(: fold-tree (All (A R) (-> (Treeof A) (-> A R R) R R)))
(define (fold-tree tree f base)
  (f (tree-value tree)
     (foldr
          (lambda ((child : (Treeof A)) (r : R))
            (fold-tree child f r))
          base
          (tree-children tree))))

现在在交互窗口中尝试，

(fold-tree (tree 1 (list (tree 2 '()))) + 0)

工作并返回

- : Integer [more precisely: Nonnegative-Integer]
3

但尝试看似等效的方法

(fold-tree (tree 1 (list (tree 2 '()))) (lambda (a r) (+ a r)) 0)

会出现很多错误。

更新： 感谢 tfb 的输入，以下调用都可以正常工作：

> (fold-tree (tree 1 (list (tree 2 '()))) (lambda ((a : Number) (r : Number)) (+ a r)) 0)
- : Number
3

> (fold-tree (tree 1 (list (tree 2 '()))) (lambda ((a : Any) (b : Any)) (cons a b)) 0)
- : (U Zero (Pairof Any Any))
'(1 2 . 0)

> (fold-tree (tree 1 (list (tree 2 '()))) (lambda ((a : Any) (b : Any)) (cons a b)) '())
- : (U Null (Pairof Any Any))
'(1 2)

> (fold-tree (tree 1 (list (tree 2 '()))) (lambda ((a : Any) (b : (Listof Any)))
     (cons a b)) '())
- : (Listof Any)
'(1 2)

> (fold-tree (tree 1 (list (tree 2 '()))) (lambda ((a : Number) (b : (Listof Number))) 
     (cons a b)) '())
- : (Listof Number)
'(1 2)

> (fold-tree (tree 1 (list (tree 2 '()))) (lambda (a b) (cons a b)) '())
- : (U Null (Pairof Any Any))
'(1 2)

> (fold-tree (tree 1 (list (tree 2 '()))) cons '())
*** Type Checker: Polymorphic function `fold-tree' could not be applied to arguments:
Argument 1:
  Expected: (Treeof A)
  Given:    (Treeof Positive-Byte)
Argument 2:
  Expected: (-> A R R)
  Given:    (All (a b) (case-> (-> a (Listof a) (Listof a)) (-> a b (Pairof a b))))
Argument 3:
  Expected: R
  Given:    Null
 in: (fold-tree (tree 1 (list (tree 2 (quote ())))) cons (quote ()))
>