Sml tycon不匹配问题

完成一项基本上需要一棵树的家庭作业，其声明如下：

datatype a BinTree = 
Leaf of a
| Node of a BinTree * a BinTree;

并返回树的整数高度的元组和存储在树最深部分的值列表

fun deepest tree = 
case tree of 
Leaf(n) => [n]
| Node(l, r) => if #1(deepest l) > #1(deepest r) then ((#1(deepest l) + 1), #2(deepest l)) else
                if #1(deepest l) < #1(deepest r) then ((#1(deepest r) + 1), #2(deepest r)) else
                (1, #2(deepest l) @ #2(deepest r)); 

fun树=
案例树
叶（n）=>[n]
|节点（l，r）=>如果#1（最深的l）>#1（最深的r），那么（#1（最深的l）+1），#2（最深的l））其他
如果#1（最深的l）<#1（最深的r），则（#1（最深的r）+1），#2（最深的r））其他
(1,2(最深左),2(最深右),；

尝试测试此代码时，我发现以下错误消息：

stdIn:43.1-47.35 Error: types of rules don't agree [tycon mismatch]
earlier rule(s): 'Z BinTree -> 'Z list
this rule: 'Z BinTree -> [+ ty] * 'Y list
in rule:
Node (l,r) =>
  if (fn <rule>) (deepest <exp>) > (fn <rule>) (deepest <exp>)
  then (<exp> <exp> + 1,(fn <rule>) (deepest <exp>))
  else if <exp> <exp> < <exp> <exp>
       then (<exp> + <exp>,<exp> <exp>)
       else (1,<exp> @ <exp>)
stdIn:21.2-47.35 Error: right-hand-side of clause doesn't agree with 
function result type [type mismatch]
expression:  'Z list
result type:  {1:[+ ty], 2:'X list; 'Y}
in declaration:
deepest =
  (fn tree =>
        (case tree
          of <pat> => <exp>
           | <pat> => <exp>))
stdIn:1.2-47.35 Error: unresolved flex record (need to know the names of ALL 
the fields
in this context)
type: {1:[+ ty], 2:'Y list; 'Z}

stdIn:43.1-47.35错误：规则类型不一致[tycon不匹配]
早期规则：“Z BinTree->”Z列表
此规则：“Z BinTree->[+ty]*”Y列表
按照规则：
节点（l，r）=>
如果（fn）（最深）>（fn）（最深）
然后（+1，（fn）（最深））
否则，如果
然后（+，）
其他（1，@）
标准：21.2-47.35错误：条款右侧与
函数结果类型[类型不匹配]
表达式：“Z列表”
结果类型：{1:[+ty]，2:'X list；'Y}
在声明中：
深沉的=
（fn树=>
（案例树）
of=>
|  => ))
stdIn:1.2-47.35错误：未解析的flex记录（需要知道所有记录的名称
田野
（在这方面）
类型：{1:[+ty]，2:'Y list；'Z}

虽然我知道这是一种类型的冲突，但我找不到冲突是什么，也找不到如何解决冲突。任何帮助都将不胜感激。

这

earlier rule(s): 'Z BinTree -> 'Z list

来自叶子大小写（

[n]

），它使它成为从树到列表的函数

这是：

this rule: 'Z BinTree -> [+ ty] * 'Y list

来自节点案例，使其成为从树到成对的“支持添加的类型”和列表的函数

剩下的错误是由于SML无法在存在冲突的情况下推断出

#1

和

#2

的含义

您的基本案例是错误的–它应该是一对，而不是一个列表。
该对中的深度应为1，如果两个子树的深度相等，则深度不应为1

在最坏的情况下，每个子树的最深值计算三次，在最好的情况下计算两次。
最好每个子树只递归一次

大概是这样的：

fun deepest (Leaf n) = (1, [n])
  | deepest (Node (l, r)) =
        case deepest l of (dl, ll) =>
        case deepest r of (dr, lr) =>
                      if dl > dr then (dl + 1, ll)
                      else if dr > dl then (dr + 1, lr)
                      else (dl + 1, ll @ lr)

虽然我也更喜欢使用like-molbdnilo编写此函数，但下面是一个使用let-in-end的示例，以证明当结果是乘积（tuple）时，它们都可以使用。由于if-then-else中有三种情况具有三种不同的结果（

dl>dr

、

dr>dl

和

dl=dr

），因此最好使用

Int compare

：

fun deepest (Leaf n) = (1, [n])
  | deepest (Node (l, r)) =
    let val (lcount, ls) = deepest l
        val (rcount, rs) = deepest r
    in case Int.compare (lcount, rcount) of
            GT => (lcount + 1, ls)
          | LT => (rcount + 1, rs)
          | EQ => (lcount + 1, ls @ rs)
    end