Question

For recursion in F#, existing documentation is clear about how to do it in the special case where it’s just one function calling itself, or a group of physically adjacent functions calling each other.

But in the general case where a group of functions in different modules need to call each other, how do you do it?

Answer 1

I don’t think there is a way to achieve this in F#. It is usually possible to structure the application in a way that doesn’t require this, so perhaps if you described your scenario, you may get some useful comments.

Anyway, there are various ways to workaround the issue – you can declare a record or an interface to hold the functions that you need to export from the module. Interfaces allow you to export polymorphic functions too, so they are probably a better choice:

// Before the declaration of modules
type Module1Funcs = 
  abstract Foo : int -> int
type Module2Funcs = 
  abstract Bar : int -> int 

The modules can then export a value that implements one of the interfaces and functions that require the other module can take it as an argument (or you can store it in a mutable value).

module Module1 = 
  // Import functions from Module2 (needs to be initialized before using!)
  let mutable module2 = Unchecked.defaultof<Module2Funcs>

  // Sample function that references Module2
  let foo a = module2.Bar(a)

  // Export functions of the module
  let impl = 
    { new Module1Funcs with 
        member x.Foo(a) = foo a }

// Somewhere in the main function
Module1.module2 <- Module2.impl
Module2.module1 <- Module1.impl

The initializationcould be also done automatically using Reflection, but that’s a bit ugly, however if you really need it frequently, I could imagine developing some reusable library for this.

In many cases, this feels a bit ugly and restructuring the application to avoid recursive references is a better approach (in fact, I find recursive references between classes in object-oriented programming often quite confusing). However, if you really need something like this, then exporting functions using interfaces/records is probably the only option.