Pattern(s) to avoid mutual recursion between functions and other objects?

I'm starting to write a toy command line datastore for fun. I am currently storing all of my interpreter's commands in a map which maps the string name of the command as the key, and the method to execute as its value. However, the DisplayHelp command needs to reference itself from the Map of Commands. The DisplayHelp method, the Commands Map, and the InterpCommand code all looks like this:

let private DisplayHelp (shellState : ShellState) =
    printfn "Available commands: "
    
    Commands // <- This is where mutual recursive reference occurs
    |> Map.map (fun k _ -> printfn "%s" k)
    |> ignore
    
    shellState

let private Commands =
    [
        "exit", Exit
        "help", DisplayHelp // <- This is the other place where mutual reference recursion occurs
        "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
    // return
    nextState
    |> ResetStateInputs

As you can see, the mutual recursion happens between the DisplayHelp method and the Commands map. I was attempting to use the and keyword to mutually define these but it seems like bad practice. What is the correct pattern to use here, or is the problem itself solved in a completely different manner?

You can get rid of mutual recursion by using the approach suggested by @Fyodor Soikin, that it by abstracting concrete reference by introducing parameter for it. In our case - to abstract reference to Commands from function DisplayHelp:

let private DisplayHelp(shellState : ShellState, commands) = // introduce parameter commands
	printfn "Available commands: "
	commands
	|> Map.map(fun k _->printfn "%s" k)
	|> ignore
	shellState
    
let rec private Commands =
	[
		"exit", Exit
		"help", fun state -> DisplayHelp(state, Commands) // pass Commands to DisplayHelp as parameter 
		"store", StoreItem
		"list", ListItems
	]
	|> Map.ofList

From theoretical standpoint it might also be interesting to eliminate recursion from Commands definition. As an option, it can be done by using Fixed-point combinator. The idea is to introduce additional parameter (f) to target function (createCommands), which should be used instead of recursive calls. In this case it is required to wrap the target function (createCommands) into fixed-point combinator (fix). The function fix is recursive itself (at least in F# implementation) but it can be used universally to eliminate any kind of recursion in general way:

// Declare fixed point combinator
let rec fix' f = lazy f (fix' f)
let fix f = (fix' f).Value

let private DisplayHelp(shellState : ShellState, commands) =
	printfn "Available commands: "
	commands
	|> Map.map(fun k _->printfn "%s" k)
	|> ignore
	shellState
    
let private createCommands (f: Lazy<_>) () = // transform value to non-recursive function and add f parameter for self referncing
	[
		"exit", Exit
		"help", fun state -> DisplayHelp(state, f.Value ()) // call f function (unwrapped from lazy) insted of recursive call
		"store", StoreItem
		"list", ListItems
	]
	|> Map.ofList

let Commands = fix createCommands () // wrap function with fixed point combinator and call it

I decided to take @Fyodor Soikin 's comment but still ended up using some recursive definition because it cuts down on complexity and paves the way for more flexibility. @Gennadii Saltyshchak 's answer is really interesting, but after some thought, packing ShellCommands into the ShellState record paves the way to also keep track of something like a ShellConfig where certain commands can flip various config flags on and off, commands can be disabled, etc (this obviously asks that each ShellCommand be turned eventually into a record/object type of its own with text names and perhaps their own help info as well, moving in a somewhat more OOP paradigm). The code I ended up with did not avoid recursion, but it is still cleaner than what I was originally trying to carve out. Here's the code:

type private ShellCommand = ShellState -> ShellState
and private ShellState =
    {
        PromptInput: string
        Command: string
        Arguments: string list
        ItemsStored: string list
        Running: bool
        AvailableCommands: Map<string, ShellCommand>
    }
    with 
    static member init(availableCommands: Map<string, ShellCommand>) : ShellState =
        {
            PromptInput = ""
            Command = ""
            Arguments = []
            ItemsStored = []
            Running = true
            AvailableCommands = availableCommands
        }

/// ... snip ...

let private DisplayUnrecognizedCommand : ShellCommand = fun shellState ->
    eprintf $"Command not recognized: {shellState.Command}"
    shellState

let private DisplayHelp : ShellCommand = fun shellState ->
    printfn "Available commands: "

    shellState.AvailableCommands
    |> Map.map (fun k _ -> printfn "%s" k)
    |> ignore
    
    shellState

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


let private Prompt (shellState: ShellState) =
    printf "> "
    let input = Console.ReadLine().Trim()
    { shellState with 
        PromptInput = input }

let rec private Run (shellState : ShellState) =
    if(shellState.Running) then
        shellState
        |> Prompt
        |> ParseInput
        |> InterpCommand
        |> Run
    else
        ()

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

let StartShell () =
    Run(ShellState.init(AvailableCommands))

(However since I did not avoid recursion as I had asked in the original question, I'll accept the other answer as the right one