Mutually recursive non-function values with intermediate module definition not initialized incorrectly

Repro steps

Consider the following code:

type Node =
    {
        Next: Node
        Prev: Node
        Value: int
    }

let rec one =
    {
        Next = two
        Prev = two
        Value = 1
    }

and two =
    {
        Next = one
        Prev = one
        Value = 2
    }
printfn "%A" one
printfn "%A" two

Expected behavior

Either:

Correctly initialize the mutually recursive values.
Reject the code as being invalid.

Actual behavior

The code compiles with no warnings/errors. two is initialized correctly, but one.Next and one.Prev are both null:

{ Next = null
  Prev = null
  Value = 1 }
{ Next = { Next = null
           Prev = null
           Value = 1 }
  Prev = { Next = null
           Prev = null
           Value = 1 }
  Value = 2 }

Known workarounds

None

Related information

Decompiled C# code with incorrect initialization.

Note that a single self-referencing value is actually initialized correctly:

let rec zero =
    {
        Next = zero
        Prev = zero
        Value = 0
    }

Ugh, thanks for the bug report. We have an extensive systematic test suite somewhere for almost exactly this case and I can't quite believe this one slipped through, but eveidently it did. I'll get it fixed. I'm impressed you found this.

There is one case not fixed by #12395. I'll leave this open to track this, though won't immediately seek to fix it

module rec Test12384d =
    type Node =
        {
            Next: Node
            Value: int
        }

    let one =
        {
            Next = two
            Value = 1
        }

    module M =
        let x() = one
        
    let two =
        {
            Next = one
            Value = 2
        }

I tried this

  type Parent = {
      Name : string
      Age : int
      Children : Child list }
  and Child = {
      Name : string
      Parent : Parent }    

  let createParent name children = 
    { Name = name
      Age = 42
      Children = children }

  let createChild name parent = 
    { Name = name
      Parent = parent }

  let create name kids =
      let rec makeChild name = createChild name parent
      and makeParent name = createParent name children
      and parent = name |> makeParent 
      and children = kids |> List.map makeChild
      parent

  create "Peter" [ "Sarah"; "Max" ]
  |> printfn "%A"

and i get "Children" printed as "null"

am i doing something wrong or is this bug really still open?

Fix struct/closure byref capture and let-rec initialization order

🤖 This is an automated response from Repo Assist.

This issue appears to be fixed in recent versions of the F# compiler. Mutually recursive non-function values are now correctly initialized — one.Next and one.Prev no longer end up as null.

Verified with current compiler:

type Node = { Next: Node; Prev: Node; Value: int }

let rec one = { Next = two; Prev = two; Value = 1 }
and two    = { Next = one; Prev = one; Value = 2 }

printfn "one.Next is null: %b" (obj.ReferenceEquals(one.Next :> obj, null))
// Output: one.Next is null: false  ✅
printfn "one.Next.Value = %d" one.Next.Value
// Output: one.Next.Value = 2  ✅  (correctly points to `two`)

Maintainer: please verify and close if confirmed.

Generated by Repo Assist · ◷

To install this agentic workflow, run
gh aw add githubnext/agentics/workflows/repo-assist.md@9135cdfde26838a01779aa966628308404ec1f02

This does NOT appear to be completely fixed. While my original example now works, Don's example does not.

FWIW, this is the second time in the last few days that this bot has incorrectly prompted me to close an issue.

@T-Gro

@T-Gro The issue is not fixed, per the comment above.

Please, let's not close issues based on the bot responses only?

Related test:

fsharp/tests/fsharp/core/letrec/test.fsx

Lines 644 to 669 in d04f46f

    
           module Test12384 = 
        
               type Node = 
        
                   { 
        
                       Next: Node 
        
                       Value: int 
        
                   } 
        
               let rec one = 
        
                   { 
        
                       Next = two 
        
                       Value = 1 
        
                   } 
        
               and two = 
        
                   { 
        
                       Next = one 
        
                       Value = 2 
        
                   } 
        
               printfn "%A" one 
        
               printfn "%A" two 
        
               test "cweewlwne1" one.Value 1 
        
               test "cweewlwne2" one.Next.Value 2 
        
               test "cweewlwne3" one.Next.Next.Value 1 
        
               test "cweewlwne4" two.Value 2 
        
               test "cweewlwne5" two.Next.Value 1 
        
               test "cweewlwne6" two.Next.Next.Value 2

Test12384 creates the exact mutually recursive record values from the issue (let rec one = { Next = two; Value = 1 } and two = { Next = one; Value = 2 }). It asserts one.Next.Value = 2 and one.Next.Next.Value = 1, which would fail if one.Next were null as described in the bug.

Additional variants at L671-L700 (with nested module after bindings) and L702-L731 (module rec) cover related configurations.

None of those tests replicate Don's example, which still fails in the latest version of Visual Studio (18.4.1):

module rec Test12384d =
    type Node =
        {
            Next: Node
            Value: int
        }

    let one =
        {
            Next = two
            Value = 1
        }

    module M =
        let x() = one
        
    let two =
        {
            Next = one
            Value = 2
        }

    printfn "%A" one
    printfn "%A" two

Output:

{ Next = null
  Value = 1 }
{ Next = { Next = null
           Value = 1 }
  Value = 2 }

Note that Don even retitled this issue to describe the remaining problem precisely: "Mutually recursive non-function values with intermediate module definition not initialized incorrectly", but none of your tests cover the case of a module defined BETWEEN one and two. In your test file, the failing test (Test12384d) is actually commented out for some reason:

Note, this case doesn't initialize successfully because of the intervening module. Tracked by #12384

My apologies, reopening

@auduchinok

Thanks for the vigilance @auduchinok and @brianberns

Navigation Menu

Repository navigation

Mutually recursive non-function values with intermediate module definition not initialized incorrectly #12384

7 remaining items

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

	module Test12384 =
	type Node =
	{
	Next: Node
	Value: int
	}

	let rec one =
	{
	Next = two
	Value = 1
	}

	and two =
	{
	Next = one
	Value = 2
	}
	printfn "%A" one
	printfn "%A" two
	test "cweewlwne1" one.Value 1
	test "cweewlwne2" one.Next.Value 2
	test "cweewlwne3" one.Next.Next.Value 1
	test "cweewlwne4" two.Value 2
	test "cweewlwne5" two.Next.Value 1
	test "cweewlwne6" two.Next.Next.Value 2

Mutually recursive non-function values with intermediate module definition not initialized incorrectly #12384

Description

Activity

dsyme commented on Nov 15, 2021

dsyme commented on Nov 19, 2021

plainionist commented on Mar 23, 2024

7 remaining items

github-actions commented on Mar 22, 2026

brianberns commented on Mar 22, 2026

auduchinok commented on Mar 23, 2026

T-Gro commented on Mar 24, 2026

brianberns commented on Mar 24, 2026

T-Gro commented on Mar 24, 2026

dsyme commented on Mar 24, 2026

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions