F# 中的循环函数/类型依赖

Question

我有一个关于执行以下操作的最佳方法的问题

我有一个 B 类，我在 B 上有一个组合器， 让 foo : B ->国际。

我希望 B 类将组合器封装为方法，因此我添加了类型扩展。

后来我意识到 foo 相当昂贵，并且想要通过惰性求值缓存它的结果

所以我通过将组合器作为函数传递给构造函数，然后使用 foo = lazy(foo self 初始化一个字段，为系统添加了一个巨大的离合器）在构造函数中。

即，

type foo =
    class
        val x : int Lazy

         new (comb) as self = {x=lazy(comb self);}
     end
 let something (x:foo) = 1

 type foo with
      new() = foo(something)

这显然感觉不对，

我看到的修复此问题的两个选项是1，创建一个接口并让 foo 继承该接口，2，将所有内容都设为静态方法，然后从这些静态方法中创建组合器（与附加它们相反）去上课...）

这些都不是非常有吸引力，我想知道我是否错过了选项 3

哦，而且我还没有能够得到让REC并正确地处理这个问题，我也不想像“上述语句中的“某物”依赖于一个函数，该函数又依赖于一个函数，而该函数又依赖于一个函数（深度为 3）。

任何建议将不胜感激

Answer 1

我不认为你目前的设计有什么问题。关键点是，如果您在同一文件（和同一模块）中定义类型 Foo 以及该类型的扩展，那么 F# 会将定义的两部分合并为一个.NET 类型。因此，它被定义为两个单独的部分这一事实只是一个实现细节。

如果您不想公开采用组合器的构造函数，可以将其标记为private。加上一些额外的更改（即使用隐式构造函数语法），代码片段将如下所示：

type Foo private (comb) as self =
  let x : Lazy<int> = lazy comb self

let something (x:Foo) = 1

type Foo with
  new() = Foo(something)

如果您想将 something 保留为单独的函数，那么这是一个很好的解决方案。 F# PowerPack 中的许多数字类型都遵循此模式（例如，请参阅复数的定义< /a>)

Answer 2

我不太明白你想要什么，但我认为这可能会有所帮助：

type foo(comb) as self =
    let x = lazy(comb self)
    static member something (x:foo) = 1 
    new() = foo(foo.something)

类型可以用它自己的静态成员递归，所以这是编写代码的更简单的方法。