Recursion and anonymous functions in elixir

Question

I'm trying to define an anonymous function to do a dot product, I can code this as a private function without any problem but I am struggling with the anonymous function syntax. I know I could implement this differently but I am trying to understand how to define anonymous functions with pattern matching and recursion. This is my current implementation

dot = fn
  [i|input],[w|weights], acc -> dot.(input,weights,i*w+acc)
  [],[bias],acc -> acc + bias
end

And I get this error on compile:

function dot/0 undefined

Any hints? Is this just not possible?

// , Excellent question, Batou99. Do you know if there's anything about this, specifically, in the Elixir documentation? Might be a good candidate for the FAQ page. — Nathan Basanese, Sep 15 '15 at 22:08
Not as far as I know. But José Valim added some comment about this may be changing due to changes in Erlang 17, we are now at Erlang 18 so this definitely may have changed already. — Batou99, Sep 22 '15 at 11:52

score 40 · Accepted Answer · answered Feb 24 '14 at 09:17

40

It is not possible to recur on anonymous functions in Elixir.

Erlang 17 (currently a release candidate) adds this possibility to Erlang and we plan to leverage it soon. Right now, the best approach is to define a module function and pass it around:

def neural_bias([i|input],[w|weights], acc) do
  neural(input,weights,i*w+acc)
end

def neural_bias([], [bias], acc) do
  acc + bias
end

And then:

&neural_bias/3

answered Feb 24 '14 at 09:17

José Valim

50,409
12
130
115

Then I think I prefer using private functions with defp. – Batou99 Feb 24 '14 at 11:38
1

Yup. It was just an example, it will also work as a private function. – José Valim Feb 24 '14 at 13:41
5

Does elixir now support recursing anonymous functions? – CMCDragonkai Aug 04 '14 at 02:33
1

Not yet, we had plans but we couldn't agree on a syntax so it has been postponed to after 1.0. – José Valim Aug 04 '14 at 11:32
4

@JoséValim where could we follow debates about this subject ? – lud Feb 13 '15 at 12:50
The elixir-lang-core mailing list is where those discussions happen. It has become quite low-volume though after 1.0 was out. – José Valim Feb 13 '15 at 14:02
3

As noted [here](http://stackoverflow.com/a/25829932/1276737) it is possible to define a recursive function using only anonymous function using the excellent fix point combinator (Y combinator). Though I guess the asker was expecting first class language support without having to use `Y`. – Mahesh Dec 05 '15 at 15:48
3

@JoséValim Has this been added yet? – Peter R Jul 28 '16 at 23:51
1

From what I know it's still not here – Krzysztof Wende Sep 07 '17 at 11:08
1

how is this still not a thing – Jo King May 21 '22 at 02:18

score 37 · Answer 2 · answered Sep 20 '14 at 14:28

37

The less formal but still acceptable approach is:

factorial = fn
  (0,_) -> 1
  (1,_) -> 1
  (n, fun) -> n * fun.(n - 1, fun)
end

You call it with factorial.(6, factorial) # 720

answered Sep 20 '14 at 14:28

hamiltop

453
6
9

That's kind of like PHP's &referencing style. – CMCDragonkai Sep 30 '14 at 13:13

score 13 · Answer 3 · answered Sep 14 '14 at 03:56

Here's a fixed (Y) combinator:

fix = fn f -> 
    (fn z ->
        z.(z)
    end).(fn x -> 
        f.(fn y -> (x.(x)).(y) end)
    end)
end

Here's how you use it:

factorial = fn factorial ->
    fn
        0 -> 0
        1 -> 1
        number -> number * factorial.(number - 1)
    end
end

fix.(factorial).(6) # 720

Only works with functions that recurse with 1 argument. Elixir doesn't have variable arguments. To support multiple arguments, you'll need to add more arguments than the single y like: f.(fn a,b -> (x.(x)).(a,b) end).

I would call the original function `factorial_stub` and `factorial = fix.(factorial_stub)`. Simple change but makes it a little clearer to first timers IMO. — Mahesh, Dec 05 '15 at 15:47

Ramon Snir · Answer 4 · 2014-02-24T15:44:31.593

3

You could define a module-function called fix, and use it later to define dot (and any other recursing anonymous function):

defmodule A do
    def fix(f, x) do
      f.(fn(x) -> fix(f, x) end, x)
    end

    def fix2(f, x, y) do
      f.(fn(x, y) -> fix2(f, x, y) end, x, y)
    end
end

dot = fn(x, y) ->
    A.fix2(fn
          dot, [i|input],[w|weights], acc -> dot.(input,weights,i*w+acc)
          dot, [],[bias],acc -> acc + bias
    end, x, y)
end

edited Feb 24 '14 at 15:44

answered Feb 24 '14 at 09:28

Ramon Snir

7,520
3
43
61

1

Is this the y-combinator? – CMCDragonkai Aug 04 '14 at 02:34
2

Essentially, a fixed-point combinator: https://en.wikipedia.org/wiki/Fixed-point_combinator – Parker Selbert Aug 04 '14 at 02:36
I see that there is fix1 and fix2, can there be a single fix or any number of arguments? – CMCDragonkai Sep 12 '14 at 08:38
@CMCDragonkai I'm not using Elixir anymore, and it has changed a lot since I stopped. You should open a new question if you'd like to get an answer to that. – Ramon Snir Sep 12 '14 at 12:30

score 0 · Answer 5 · answered Apr 04 '22 at 11:13

Constructing on @hamiltop answer, if you don't to always pass the fn yourself during calls, you can then wrap it:

factorial_rec = fn
  (0,_) -> 1
  (1,_) -> 1
  (n, fun) -> n * fun.(n - 1, fun)
end

factorial = fn n ->
  factorial_rec.(n, factorial_rec)
end

So you can call it as factorial.(6)

Recursion and anonymous functions in elixir

5 Answers5

Linked