Recursion with anonymous function?

[aage]

Can an anonymous (local) function call itself?

I want to use such a function for tail recursion, like so:

import gleam/list

pub fn accumulate(l: List(a), fun: fn(a) -> b) -> List(b) {
  let inner = fn(data: List(a), acc: List(b)) -> List(b) {
    case data {
      [] -> list.reverse(acc)
      [head, ..tail] -> {
        let acc_ = [fun(head), ..acc]
        inner(tail, acc_)
      }
    }
  }
  inner(l, [])
}

But the inner function cannot be called from itself. Is there any way to do this in this manner? I know I can extract this to a private fn outside of the scope of accumulate.

I guess this would also be solved using the Optional arguments with defaults feature (which isn't there yet right?) in the outer accumulate function.

Thank you

[lpil]

Hello! Anonymous functions cannot be recursive, typically a top level private function is used instead.

[lambdam]

Hello,

I have been experimenting with Gleam for some time and bumped into this question while trying to implement a tail recursive function of the Fibonacci sequence.
I tried to implement it in Gleam in a similar way to this OCaml function:

let fib target =
  let rec fib' n f_minus_1 f_minus_2 =
    let sum = f_minus_1 + f_minus_2 in
    if n = target
    then sum
    else fib' (n + 1) sum f_minus_1
  in
  match target with
  | 0 -> 0
  | 1 -> 1
  | _ -> fib' 2 1 0

I figured out after some searches that it was impossible to do with Gleam for the time being and had to move the closure to a top level function.

Also while searching on this subject, I figured out that Erlang has anonymous named functions since version 17 (see the "Update" section in the middle of the page).
I put some some exploratory code in a Github repository with:

• The Erlang version the OCaml function above.
• Some exploratory syntax for potential Gleam named anonymous functions.

@lpil since Erlang exposes this feature, is there a particular reason for not having it in Gleam?

Thanks

[lambdam]

Thanks for the quick response.

I did it here https://github.com/lambdam/gleam-ocaml-erlang-fibonacci/blob/master/beam_fibonacci/exploration/exploration.gleam with two versions.

The first one (fib_v1) is closer to the OCaml version and is, I think, the most elegant one since there are less repetitions of names (compared to fib_v2).

The second one is (fib_v2) is the equivalent of the Erlang version of the function and is more verbose with more similar names spreading around.

[lambdam]

@lpil any preference?
I personally like this one better:

fn fib_v1(target) {
  fn fib_acc(n, f_minus_1, f_minus_2) {
    let sum = f_minus_1 + f_minus_2
    case n {
      _ if n == target -> sum
      _ -> fib_acc(target, n + 1, sum, f_minus_1)
    }
  }
  case n {
    0 -> 0
    1 -> 1
    _ -> fib_acc(2, 1, 0)
  }
}

But we could also consider a third option:

 fn fib_v3(target) {
  let fib_acc = fn(n, f_minus_1, f_minus_2) {
    let sum = f_minus_1 + f_minus_2
    case n {
      _ if n == target -> sum
      _ -> fib_acc(target, n + 1, sum, f_minus_1)
    }
  }
  case n {
    0 -> 0
    1 -> 1
    _ -> fib_acc(2, 1, 0)
  }
}

[lpil]

To make a language change we'll need to cover what the problems we have today, for example real-world things that the language cannot do, or are difficult or annoying to do; what some proposed solutions might be and their trade-offs; and the impact this has on the overall language and and the ecosystem. Once we have this and discussed it we'll be in a place to decide if another round of this design loop is needed or if there's something to implement.

[lambdam]

I completely understand.
I am rewriting (when I manage to have some free time) a former real world project that was written in Clojure with Netty* as the underlying network tool.
I had to deal with low level details to reach the level of processing speed required by the project.
I really wanted to compare it with a BEAM implementation of the same project. To see if we could have the same level of processing speed without dealing with low level details. I am currently trying to write it with Gleam.
If I bump into real world problems, I'll come back to a discussion.

Also, I'll add a last piece of code to this Github discussion to have all the code snippets into it.
Here is a working Gleam version of the fibonacci sequence with accumulator:

fn fib_acc(target, n, f_minus_1, f_minus_2) {
  let sum = f_minus_1 + f_minus_2
  case n {
    _ if n == target -> sum
    _ -> fib_acc(target, n + 1, sum, f_minus_1)
  }
}

fn fib(n) {
  case n {
    0 -> 0
    1 -> 1
    _ -> fib_acc(n, 2, 1, 0)
  }
}

Thanks for all the great work.

* The libraries directly used with Clojure that wrap Netty are Aleph and Manifold.

[lpil]

That sounds like a really cool project! Keen to hear how it turns out