Nested / Anonymous (auxiliary) recursive functions

[nohehf]

In functional programming, auxiliary recursive functions are a common pattern I think (at least from my experience).
For instance in ocaml you can implement factorial as:

let factorial n =
  let rec aux acc n =
    if n = 0 then acc
    else aux (acc * n) (n - 1)
  in aux 1 n

(I know that this is not the best factorial implementation, and that in this case the aux function can be considered and anti-pattern, but that is an other debate, and the example is simple).

This does not seem to be possible in gleam however as in gleam only module-level functions can be named:

pub fn factorial(n) {
  fn aux() {} //  Syntax error I was not expecting this. Found a name, expected one of:  - `(` Hint: Only module-level functions can be named.
}

And anonymous function handle (variable) won't be in scope of the said function

pub fn factorial(n) {
  let aux = fn() {
     aux() //  Unknown variable The name `aux` is not in scope here. (hence the rec keyword in ocaml)
  } 
}

I tried to pass the function as a callback argument as a ungly workaround, but cannot be typed correctly I think (recursive types):

// invalid tentative
pub fn factorial(n) {
  // aux cannot be typed (as it would result in fn(Int, Int, fn(Int, Int, ...))
  let aux = fn(acc: Int, n: Int, aux) {
    case n {
      0 -> acc
      _ -> aux(acc * n, n - 1, aux)
    }
  }
  aux(1, n, aux)
}

So I wonder:

• What is the rationale behind the rule "only module-level functions can be named" ?
• Is there another way to achieve this ? (Other than two module-level functions) ?
• Would a rec like keyword be envisageable in gleam ?

rec would allow something like:

// invalid tentative
pub fn factorial(n) {
  let rec aux = fn(acc: Int, n: Int) {
    case n {
      0 -> acc
      _ -> aux(acc * n, n - 1)
    }
  }
  aux(1, n)
}

(or maybe rec would not even be needed ? That would be even cooler)

Thanks!

PS: On a personnal note, and It seems that this have been discussed in #346 and #349, but I think having some sort of let rec in, or another solution to make top level and nested function the same would be really nice. I've been loving gleam so far, but not having a single type of function (top level could be let pub top_level_function = fn () {} feels a bit weird to me. The ability to do the same things in or out of top level context would be awesome. Thanks again for the incredible work tho, gleam has been a joy :))

[lpil]

We won't be adding recursive let as you can use a top level function of the fix point combinator function to the same effect.

[nohehf]

What do you mean by

of the fix point combinator function

And don't you think it could be nice to have the same behavior from top level and non- top level functions ?

Thanks for the quick answer !

[lpil]

It's a function that can make other functions recursive https://hexdocs.pm/funtil/funtil.html#fix

And don't you think it could be nice to have the same behavior from top level and non- top level functions ?

No, this is by design.

[nohehf]

It's a function that can make other functions recursive https://hexdocs.pm/funtil/funtil.html#fix

Thanks that's exactly what I was looking for