Lisp Flavored Erlang - Primitivas de mensajería

Question

He leído toda la documentación y la mayoría de las fuentes de LFE. Todas las presentaciones enfatizan el ceceo básico en roles tradicionales de lisp: resolución general de problemas, Hello World y macros de emulación de sintaxis.

¿Alguien sabe cómo LFE maneja las primitivas de mensajería? Para especificar una pregunta más precisa, ¿cómo expresar esta Erlang:

A = 2, 
Pid = spawn(fun()-> 
    receive 
     B when is_integer(B) -> io:format("Added: ~p~n",[A+B]); 
     _ -> nan 
    end 
end), 
Pid ! 5. 

Y luego, ya sabes, que murmura algo acerca de haber añadido algunos números y la respuesta siendo 7.

Answer 1

no estoy un usuario LFE, pero hay un user guide en el árbol de fuentes. De la lectura que yo supongo que es algo como esto:

(let ((A 2)) 
    (let ((Pid (spawn (lambda() 
         (receive 
         (B (when (is_integer B)) 
          (: io format "Added: ~p~n" (list (+ A B)))) 
         (_ nan)))))) 
    (! Pid 5))) 

pero estoy muy probable que haya cometido un error ya que no he incluso evaluado en LFE.

Algunas de las preguntas de la mina:

• ¿Existe una forma LET* forma o se comportan como uno ya?
• ¿Los protectores se llaman más lispy is-integer y no is_integer como escribí?

Answer 2

Hay una gran falta de ejemplos en la versión LFE, todas las contribuciones son bienvenidas.

La sugerencia de Christian es correcta. Mi único comentario es que no es necesario tener mayúsculas en los nombres de las variables, no está mal, pero no es necesario.

La LFE let es una entrada "real" en la que las uniones variables son visibles primero en el cuerpo. Puedes usar patrones en let. También hay un formulario let* (macro en realidad) que se une secuencialmente.

No, hasta ahora he conservado todos los nombres de funciones centrales de Erlang tal como están en vanilla erlang. Definitivamente es más liso usar - en lugar de _ en los nombres, pero ¿qué haces con los otros nombres de funciones y átomos en OTP? Una sugerencia es mapear automáticamente - en símbolos LFE a _ en los átomos resultantes, y viceversa yendo por el otro camino, por supuesto. Esto probablemente funcionaría, pero ¿daría lugar a confusión?

entonces podría tener un módulo de comportamiento buscando como:

(defmodule foo 
    (export (init 1) (handle-call 2) (handle-cast 2) (handle-info 2) ...) 
    (behaviour gen-server)) 

(defun handle-call ...) 

(defun handle-cast ...) 

etc ... 

pero soy muy ambivalente al respecto.