F#中使用module rec触发FS0040警告的原因及相关问题解析

我正在为以下F#类型编写JSON解码器：

type FullName =
  {
    FirstName : string
    LastName : string
  }

type Person =
  {
    Name : FullName
    Role : string
  }

以下代码可正常运行：

module Thoth = 

  open Thoth.Json.Net

  [<RequireQualifiedAccess>]
  module FullName =

    let decode : Decoder<FullName> =
      Decode.object
        (fun get ->
          {
            FirstName = get.Required.Field "firstName" Decode.string
            LastName = get.Required.Field "lastName" Decode.string
          })

  [<RequireQualifiedAccess>]
  module Person =

    let decode : Decoder<Person> =
      Decode.object
        (fun get ->
          {
            Name = get.Required.Field "name" FullName.decode
            Role = get.Required.Field "role" Decode.string
          })

但当我希望不必在意声明顺序，使用module rec编写时，代码仍可运行但触发编译器警告：

module rec Thoth =

  open Thoth.Json.Net

  [<RequireQualifiedAccess>]
  module Person =

    let decode : Decoder<Person> =
      Decode.object
        (fun get ->
          {
            Name = get.Required.Field "name" FullName.decode
            Role = get.Required.Field "role" Decode.string
          })

  [<RequireQualifiedAccess>]
  module FullName =

    let decode : Decoder<FullName> =
      Decode.object
        (fun get ->
          {
            FirstName = get.Required.Field "firstName" Decode.string
            LastName = get.Required.Field "lastName" Decode.string
          })

警告内容：

warning FS0040: This and other recursive references to the object(s) being defined will be checked for initialization-soundness at runtime through the use of a delayed reference. This is because you are defining one or more recursive objects, rather than recursive functions. This warning may be suppressed by using '#nowarn "40"' or '--nowarn:40'.

现提出三个技术问题：

1. 抑制该FS0040警告会有什么后果？
2. 不采用第一种写法的前提下，有没有无警告使用module rec的方式？
3. 另外发现使用static member编写解码器不会触发警告，这种方式与上述module rec写法在性能上是否等价？

附上static member写法的代码：

module rec Domain =

  open Thoth.Json.Net

  type Person =
    {
      Name : FullName
      Role : string
    }
    with
      static member Decode : Decoder<Person> =
        Decode.object
          (fun get ->
            {
              Name = get.Required.Field "name" FullName.Decode
              Role = get.Required.Field "role" Decode.string
            })

  type FullName =
    {
      FirstName : string
      LastName : string
    }
    with
      static member Decode : Decoder<FullName> =
        Decode.object
          (fun get ->
            {
              FirstName = get.Required.Field "firstName" Decode.string
              LastName = get.Required.Field "lastName" Decode.string
            })

问题解答 #

1. 抑制FS0040警告的后果 #

抑制警告本身不会让代码出错，只是关掉了编译器对递归对象初始化方式的提醒。编译器发警告是因为它没法在编译期确认递归引用的对象能否正确初始化，会通过延迟引用（类似惰性求值）保证运行时的初始化安全。只要你的解码器逻辑不在初始化阶段触发递归调用（比如Person.decode初始化时只是持有FullName.decode的引用，不会立即执行它的解码逻辑），抑制警告完全没问题。唯一潜在风险是：未来改代码时如果不小心引入了初始化阶段的循环依赖，编译器不会再提醒你，可能导致运行时出现空引用或初始化异常。

2. 无警告使用module rec的方式 #

有两种常用方法可以避免该警告：

• 将解码器定义为函数而非值：把let decode改成let decode () =，调用时加括号。这样编译器会把它当成递归函数而非递归对象，不会触发FS0040。示例代码：

  module rec Thoth =
    open Thoth.Json.Net
  
    [<RequireQualifiedAccess>]
    module Person =
      let decode () : Decoder<Person> =
        Decode.object (fun get ->
          {
            Name = get.Required.Field "name" (FullName.decode ())
            Role = get.Required.Field "role" Decode.string
          })
  
    [<RequireQualifiedAccess>]
    module FullName =
      let decode () : Decoder<FullName> =
        Decode.object (fun get ->
          {
            FirstName = get.Required.Field "firstName" Decode.string
            LastName = get.Required.Field "lastName" Decode.string
          })
  

• 用惰性值lazy包裹解码器：把解码器定义为惰性值，延迟初始化时机，编译器能确认初始化安全，就不会发警告。调用时需要用Force()提取值：

  module rec Thoth =
    open Thoth.Json.Net
  
    [<RequireQualifiedAccess>]
    module Person =
      let decode = lazy (
        Decode.object (fun get ->
          {
            Name = get.Required.Field "name" (FullName.decode.Force())
            Role = get.Required.Field "role" Decode.string
          }) : Decoder<Person>
      )
  
    [<RequireQualifiedAccess>]
    module FullName =
      let decode = lazy (
        Decode.object (fun get ->
          {
            FirstName = get.Required.Field "firstName" Decode.string
            LastName = get.Required.Field "lastName" Decode.string
          }) : Decoder<FullName>
      )
  

3. static member与module rec的性能等价性 #

这两种写法在性能上几乎没有区别：

• 两者都是在类型/模块加载时初始化解码器，初始化逻辑完全一致——都是构建Thoth的Decoder对象，本质是函数组合的结果。
• static member不会触发警告，是因为F#编译器对类型静态成员的递归引用处理方式不同：它会确保静态成员的初始化是延迟且安全的，不需要额外的运行时检查，因此不会发出警告。
• 运行时调用解码器时，两者的执行路径完全相同，不会有性能差异。硬要找区别的话，静态成员的访问可能有极其微小的类型查找开销，但实际应用中完全可以忽略。

内容的提问来源于stack exchange，提问作者sdgfsdh