recursion - Recursión y funciones anónimas en elixir

anonymous-function

Question

Intento definir una función anónima para hacer un producto de punto, puedo codificar esto como una función privada sin ningún problema, pero estoy luchando con la sintaxis de la función anónima. Sé que podría implementar esto de manera diferente, pero estoy tratando de entender cómo definir funciones anónimas con coincidencia de patrones y recursión. Esta es mi implementación actual

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

Y obtengo este error en la compilación:

function dot/0 undefined

¿Algún consejo? ¿Esto simplemente no es posible?

Answer 1

Aquí hay un combinador fijo (Y):

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

Así es como lo usa:

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

fix.(factorial).(6) # 720

Solo funciona con funciones que se repiten con 1 argumento. Elixir no tiene argumentos variables. Para admitir argumentos múltiples, deberá agregar más argumentos que el simple y like: f.(fn a,b -> (x.(x)).(a,b) end) .

Answer 2

El enfoque menos formal pero aún aceptable es:

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

Usted lo llama con factorial.(6, factorial) # 720

Answer 3

No es posible recurrir a funciones anónimas en Elixir.

Erlang 17 (actualmente un candidato de lanzamiento) agrega esta posibilidad a Erlang y planeamos aprovecharla pronto. En este momento, el mejor enfoque es definir una función de módulo y pasarla:

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

Y entonces:

&neural_bias/3

Answer 4

Podría definir una función de módulo llamada fix , y usarla más tarde para definir dot (y cualquier otra función anónima recurrente):

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