如何避免函数与对象间的相互递归？F#命令行工具场景咨询

我正在开发一个玩具级命令行数据存储工具，目前将解释器的所有命令存储在一个Map中，以命令字符串名称为键、执行方法为值。但DisplayHelp命令需要引用Commands Map，而Commands Map又包含DisplayHelp，形成了相互递归。相关代码如下：

let private DisplayHelp (shellState : ShellState) =
    printfn "Available commands: "
    
    Commands // <- 递归引用点
    |> Map.map (fun k _ -> printfn "%s" k)
    |> ignore
    
    shellState

let private Commands =
    [
        "exit", Exit
        "help", DisplayHelp // <- 另一处递归引用点
        "store", StoreItem
        "list", ListItems
    ]
    |> Map.ofList

let private InterpCommand (shellState : ShellState) =
    let nextState =
        match Commands.Keys.Contains shellState.Command with
        | true ->
            shellState
            |> Commands[shellState.Command]
        | false ->
            shellState
            |> DisplayUnrecognizedCommand
    nextState
    |> ResetStateInputs

我曾尝试使用and关键字定义两者，但认为这是不良实践。请问正确的解决模式是什么，或是有其他完全不同的解决方案？

方案1：依赖注入（推荐） #

通过将Commands作为参数传入DisplayHelp，彻底打破循环依赖，让DisplayHelp不再依赖全局状态，同时提升代码的可测试性。

修改代码如下：

// 让DisplayHelp接收命令映射作为参数
let private DisplayHelp (commands: Map<string, ShellState -> ShellState>) (shellState : ShellState) =
    printfn "Available commands: "
    
    commands
    |> Map.iter (fun k _ -> printfn "%s" k)
    |> ignore
    
    shellState

let private Commands =
    // 递归定义命令映射，将自身传入help命令
    let rec commands = 
        [
            "exit", Exit
            "help", DisplayHelp commands
            "store", StoreItem
            "list", ListItems
        ]
        |> Map.ofList
    commands

// 解释命令逻辑保持不变
let private InterpCommand (shellState : ShellState) =
    let nextState =
        match Commands.Keys.Contains shellState.Command with
        | true ->
            shellState
            |> Commands[shellState.Command]
        | false ->
            shellState
            |> DisplayUnrecognizedCommand
    nextState
    |> ResetStateInputs

方案2：延迟初始化 #

使用F#的Lazy类型包装Commands，延迟其求值时机，避免初始化阶段的循环引用冲突。这种方式改动最小，适合快速修复问题。

let private DisplayHelp (shellState : ShellState) =
    printfn "Available commands: "
    
    // 通过Value属性获取延迟初始化的Map
    Commands.Value
    |> Map.iter (fun k _ -> printfn "%s" k)
    |> ignore
    
    shellState

// 用lazy包装命令Map的创建逻辑
let private Commands = lazy (
    [
        "exit", Exit
        "help", DisplayHelp
        "store", StoreItem
        "list", ListItems
    ]
    |> Map.ofList
)

let private InterpCommand (shellState : ShellState) =
    let nextState =
        // 同样需要通过Value访问实际的Map
        match Commands.Value.Keys.Contains shellState.Command with
        | true ->
            shellState
            |> Commands.Value[shellState.Command]
        | false ->
            shellState
            |> DisplayUnrecognizedCommand
    nextState
    |> ResetStateInputs

方案3：分离命令元数据 #

将命令的名称和处理函数的定义单独抽离成一个列表，让DisplayHelp和Commands都依赖这个元数据列表，从根源上消除循环引用。

// 单独维护命令元数据：(命令名称, 处理函数)
let private commandDefinitions = [
    ("exit", Exit)
    ("help", DisplayHelp)
    ("store", StoreItem)
    ("list", ListItems)
]

let private DisplayHelp (shellState : ShellState) =
    printfn "Available commands: "
    // 直接从元数据列表提取命令名称
    commandDefinitions
    |> List.map fst
    |> List.iter printfn "%s"
    
    shellState

// 基于元数据列表构建命令Map
let private Commands =
    commandDefinitions
    |> Map.ofList

let private InterpCommand (shellState : ShellState) =
    let nextState =
        match Commands.Keys.Contains shellState.Command with
        | true ->
            shellState
            |> Commands[shellState.Command]
        | false ->
            shellState
            |> DisplayUnrecognizedCommand
    nextState
    |> ResetStateInputs

关于and关键字的说明 #

其实在F#中，使用and关键字定义相互递归的实体是语言原生支持的标准写法，并不属于不良实践。如果只是想快速解决循环引用问题，也可以直接用这种方式：

let private rec DisplayHelp (shellState : ShellState) =
    printfn "Available commands: "
    
    Commands
    |> Map.iter (fun k _ -> printfn "%s" k)
    |> ignore
    
    shellState

and private Commands =
    [
        "exit", Exit
        "help", DisplayHelp
        "store", StoreItem
        "list", ListItems
    ]
    |> Map.ofList

这种方式代码最简洁，适合小型项目或玩具工具的场景。

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