F#错误FS0695，此递归绑定使用无效的递归形式混合

以下代码导致编译器错误：“FS0695:此递归绑定使用无效的递归形式混合。”

错误消息是什么意思？我应该如何更正此代码

---

该代码用于初始化带有循环引用的F#不可变记录。我尝试应用这些解决方案，但没有成功。

我不熟悉这个错误，而且它似乎没有在任何地方被记录下来，但在玩了一会儿之后，我可以猜到以下内容

问题似乎在于

父项

如何被lambda表达式关闭，而lambda表达式本身在

子项

的定义中。这显然会使类型检查器失效（）——我的猜测是因为

子类

绑定本身的右侧包含一个表达式（lambda表达式），该表达式本身包含一个递归引用，但真正的原因可能比这更微妙。请注意，如果您像这样反转声明：

let createParent parentName childNames =
    let rec parent = {
        ParentName = parentName
        Children = children }
    and children = childNames |> List.map (fun childName -> createChild parent childName)
    parent

let createParent parentName childNames =
    let rec parent = {
        ParentName = parentName
        Children = children }
    and children = childNames |> List.map (createChild parent)
    parent

您还会在绑定

子项的行中看到此警告：

警告：将通过使用延迟引用在运行时检查对所定义对象的此引用和其他递归引用的初始化可靠性。这是因为您正在定义一个或多个递归对象，而不是递归函数

要解决此问题，似乎可以将封口拉出一层：

let createParent parentName childNames =
    let rec makeChild n = createChild parent n 
    and parent = {
        ParentName = parentName
        Children = children }
    and children = childNames |> List.map makeChild
    parent

或者像这样将
parent
参数转换为
createChild
方法中的值（注意
makeChild
必须在
parent
之后声明）：

或者更简单地说：

let createParent parentName childNames =
    let rec parent = {
        ParentName = parentName
        Children = children }
    and children = childNames |> List.map (fun childName -> createChild parent childName)
    parent

let createParent parentName childNames =
    let rec parent = {
        ParentName = parentName
        Children = children }
    and children = childNames |> List.map (createChild parent)
    parent

我对这个错误并不熟悉，而且似乎也没有任何文档记录，但在对它进行了一点研究之后，我可以猜测到这一点

问题似乎在于
父项
如何被lambda表达式关闭，而lambda表达式本身在
子项
的定义中。这显然会使类型检查器失效（）——我的猜测是因为
子类
绑定本身的右侧包含一个表达式（lambda表达式），该表达式本身包含一个递归引用，但真正的原因可能比这更微妙。请注意，如果您像这样反转声明：

let createParent parentName childNames =
    let rec parent = {
        ParentName = parentName
        Children = children }
    and children = childNames |> List.map (fun childName -> createChild parent childName)
    parent

let createParent parentName childNames =
    let rec parent = {
        ParentName = parentName
        Children = children }
    and children = childNames |> List.map (createChild parent)
    parent

您还会在绑定
子项的行中看到此警告：

警告：将通过使用延迟引用在运行时检查对所定义对象的此引用和其他递归引用的初始化可靠性。这是因为您正在定义一个或多个递归对象，而不是递归函数

要解决此问题，似乎可以将封口拉出一层：

let createParent parentName childNames =
    let rec makeChild n = createChild parent n 
    and parent = {
        ParentName = parentName
        Children = children }
    and children = childNames |> List.map makeChild
    parent

或者像这样将
parent
参数转换为
createChild
方法中的值（注意
makeChild
必须在
parent
之后声明）：

或者更简单地说：

let createParent parentName childNames =
    let rec parent = {
        ParentName = parentName
        Children = children }
    and children = childNames |> List.map (fun childName -> createChild parent childName)
    parent

let createParent parentName childNames =
    let rec parent = {
        ParentName = parentName
        Children = children }
    and children = childNames |> List.map (createChild parent)
    parent

因为双方都需要函数而不是属性

请尝试以下方法：

let createParent parentName childNames =
    let rec children names =
        names |> List.map (fun childName -> createChild (parent ()) childName)
    and parent () = {
        ParentName = parentName
        Children = children childNames
    }
    parent ()

因为双方都需要函数而不是属性

请尝试以下方法：

let createParent parentName childNames =
    let rec children names =
        names |> List.map (fun childName -> createChild (parent ()) childName)
    and parent () = {
        ParentName = parentName
        Children = children childNames
    }
    parent ()

这将为每个孩子创建一个父实例，对吗？是的，p.s.w.g的解决方案实际上要好得多，我不知道你可以绑定这样的东西。这将为每个孩子创建一个父实例，对吗？是的，p.s.w.g的解决方案实际上好得多，我不知道你可以绑定这样的东西。你能确认我们必须有一个单独的
rec
函数，比如
makeChild
。看起来一个curried函数也会起作用
List.map（createChild parent）
而不是
List.map makeChild
似乎也能工作，而且更简单。@Wally是的，你是对的，这似乎是一个关于
parent
如何被lambda表达式关闭的问题。我找不到关于这个错误的任何文档，但我能够确定它是由类型检查器（）抛出的。@Wally我已经更新了我的答案以确保完整性。我已经提供了关于我的研究和其他一些选择的更多细节。你能确认我们必须有一个单独的
rec
函数，比如
makeChild
。看起来一个curried函数也会起作用
List.map（createChild parent）
而不是
List.map makeChild
似乎也能工作，而且更简单。@Wally是的，你是对的，这似乎是一个关于
parent
如何被lambda表达式关闭的问题。我找不到关于这个错误的任何文档，但我能够确定它是由类型检查器（）抛出的。@Wally我已经更新了我的答案以确保完整性。我提供了更多关于我的研究和其他选择的细节。