Lisp Flavored Erlang - Messaging primitive

Question

Ho letto tutta la documentazione e la maggior parte della fonte di LFE. Tutte le presentazioni enfatizzano la lisp di base nei tradizionali ruoli lisp: General Problem Solving, Hello world e i macro di emulazione della sintassi.

Qualcuno sa come LFE gestisce le primitive di messaggistica? Per specificare una domanda più precisa, come è possibile esprimere questo Erlang:

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

E poi, sai, borbotta qualcosa di avere aggiunto alcuni numeri e la risposta essendo 7.

Answer 1

Io non sono un utente LFE, ma c'è un user guide nell'albero dei sorgenti. Dalla lettura si direi che è qualcosa di simile:

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

ma sono molto probabilità di aver fatto un errore dal momento che non ho nemmeno valutata in LFE.

Alcune domande mie:

• C'è una forma LET* o è comportando come quello già?
• Le guardie chiamano il più lispy is-integer e non is_integer come ho scritto?

Answer 2

C'è una grave mancanza di esempi nella versione di LFE, tutti i contributi sono benvenuti.

Il suggerimento di Christian è corretto. Il mio unico commento è che non è necessario avere nomi di variabili in maiuscolo, non è sbagliato, ma non è necessario.

LFE let è una "vera" locazione in cui i collegamenti delle variabili sono visibili per primi nel corpo. Puoi usare i pattern in let. C'è anche un modulo let* (in realtà la macro) che si lega in sequenza.

No, finora ho mantenuto tutti i nomi delle funzioni principali di Erlang così come sono in vanilla erlang. È decisamente più lispy usare - anziché _ nei nomi, ma cosa fai con tutti gli altri nomi di funzioni e atomi in OTP? Un suggerimento è quello di mappare automaticamente - in simboli LFE a _ negli atomi risultanti, e di nuovo andare di nuovo in senso contrario. Questo probabilmente funzionerebbe, ma porterebbe alla confusione?

ho potuto quindi avere un modulo di comportamento alla ricerca come:

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

(defun handle-call ...) 

(defun handle-cast ...) 

etc ... 

ma sono molto ambivalenti riguardo.