类型定义内的F＃递归

Question

我在尝试在F＃中实现自动区分时遇到一些问题。 我认为问题出在评估不“懒惰”。

这是我的代码：

type Diff =
    {d : double; df : Diff}
    static member (+) (x : Diff, y : Diff) =
        {d = x.d + y.d; df = x.df + y.df}
    static member (-) (x : Diff, y : Diff) =
        {d = x.d - y.d; df = x.df - y.df}
    static member (*) (x : Diff, a : double) =
        {d = x.d * a; df = x.df * a}
    static member (*) (x : Diff, y : Diff) =
        {d = x.d * y.d; df = (x.df * y) + (y.df * x)}

let rec dZero = {d = 0.0; df = dZero}

let dConst x = {d = x; df = dZero}

let dId x = {d = x; df = dConst 1.0}

let test = dId 5.0

let add (x:Diff) = (x+x).d

如果我尝试使用“添加测试”，则会得到一个堆栈溢出错误，我认为这取决于类型本身中依靠（+）的（+）定义。

有什么办法可以解决这个问题？ 任何帮助将不胜感激。

非常感谢Ash

Answer 1

如您所想，问题在于F＃不使用惰性求值，并且您创建的数据结构是“无限的”（因为dZero递归引用了它自己）。 当计算+ ，话务员通话+的df值，而这又调用+在df.df值等等...

纠正此问题的一种方法是使记录的df成员显式延迟：

type Diff = 
    {d : double; df : Lazy<Diff>} 
    static member (+) (x : Diff, y : Diff) = 
        {d = x.d + y.d; df = lazy (x.df.Value + y.df.Value) } 
    static member (-) (x : Diff, y : Diff) = 
        {d = x.d - y.d; df = lazy (x.df.Value - y.df.Value) } 
    static member (*) (x : Diff, a : double) = 
        {d = x.d * a; df = lazy (x.df.Value * a) } 
    static member (*) (x : Diff, y : Diff) = 
        {d = x.d * y.d; df = lazy ((x.df.Value * y) + (y.df.Value * x)) } 

let rec dZero = {d = 0.0; df = lazy dZero} 
let dConst x = {d = x; df = lazy dZero} 
let dId x = {d = x; df = lazy dConst 1.0} 

这将仅在实际使用df值时对其进行评估，因此+操作将计算d的值，并且仅为df提供一个惰性值（如果有人需要它可以进行评估）。

另一种选择是使Diff类型成为有区别的联合，并将零表示为特殊值（而不是作为递归记录），除非您对其他内容使用递归引用，否则该方法将起作用。 该声明大致如下：

type Diff = 
    | DiffValue of double * Diff
    | DiffZero 
    static member (+) // etc...

这将使实现的时间更长，因为您需要在所有原始操作中检查“ Zero情况。 在这种情况下，您将仅创建有限的数据结构（操作员将急切地对其进行处理）。