LFE (programovací jazyk) - LFE (programming language)

LFE
Logo LFE (Lisp Flavored Erlang) .png
ParadigmaMulti-paradigma: souběžně, funkční
RodinaErlang, Lisp
NavrhlRobert Virding
VývojářRobert Virding
Poprvé se objevil2008; Před 12 lety (2008)
Stabilní uvolnění
1.3 / 4. června 2017; před 3 lety (2017-06-04)
Psací disciplínadynamický, silný
Jazyk implementaceErlang
PlošinaIA-32, x86-64
OSCross-platform
LicenceApache 2.0
Přípony názvu souboru.lfe .hrl
webová stránkalfe.io
Ovlivněno
Erlang, Společný Lisp, Maclisp, Systém, Elixír, Clojure, Hy
Ovlivněno
Joxa, souběžný Schemer

Lisp ochucený Erlang (LFE) je funkční, souběžně, odpadky shromážděny, univerzální programovací jazyk a Lisp dialekt postaveno na jádru Erlang a virtuální stroj Erlang (PAPRSEK ). LFE staví na Erlangu a poskytuje Lispovu syntaxi pro distribuovaný zápis, tolerantní k chybám, měkký reálný čas non-stop aplikace. LFE také rozšiřuje podporu Erlang metaprogramování s makry Lisp a vylepšeným vývojářským prostředím s bohatými funkcemi read – eval – tisková smyčka (REPL).[1] LFE je aktivně podporován ve všech nedávných vydáních Erlang; nejstarší podporovaná verze Erlangu je R14.

Dějiny

První vydání

Počáteční práce na LFE začaly v roce 2007, kdy Robert Virding začal vytvářet prototyp Lispu běžícího na Erlangu.[2] Tato práce byla zaměřena především na analýzu a zkoumání toho, jak může implementace vypadat. V té době nebyl používán žádný systém řízení verzí, takže sledování přesných počátečních dat je poněkud problematické.[2]

Virding oznámil první vydání LFE na internetu Erlang Otázky seznam pošty v březnu 2008.[3] Toto vydání LFE bylo velmi omezené: nezvládlo rekurzivní letrecs, binárnís, dostávatnebo Snaž se; také nepodporoval Lisp shell.[4]

Počáteční vývoj LFE byl proveden verzí R12B-0 společnosti Erlang[5] na notebooku Dell XPS.[4]

Časová osa dialektů Lisp(Upravit )
19551960196519701975198019851990199520002005201020152020
LISP 1, 1,5, LISP 2(opuštěný)
 Maclisp
 Interlisp
 Lisp stroj Lisp
 Systém R5RS R6RS R7RS malý
 NULA
 Franz Lisp
 Společný Lisp
 Le Lisp
 T
 Chez Scheme
 Emacs Lisp
 AutoLISP
 PicoLisp
 EuLisp
 ISLISP
 OpenLisp
 Schéma PLT Raketa
 GNU Guile
 Vizuální LISP
 Clojure
 Oblouk
 LFE
 Hy

Motivy

Robert Virding uvedl, že existuje několik důvodů, proč začal programovací jazyk LFE:[2]

  • Měl předchozí zkušenosti s programováním v Lispu.
  • Vzhledem k jeho předchozím zkušenostem se zajímal o implementaci svého vlastního Lispu.
  • Zejména chtěl implementovat Lisp v Erlangu: nejenže byl zvědavý, jak to bude běžet a integrovat se s Erlangem, chtěl také vidět, co by to bylo Koukni se jako.
  • Vzhledem k tomu, že pomáhal vytvářet programovací jazyk Erlang, měl za cíl vytvořit Lisp, který byl speciálně navržen tak, aby fungoval na BEAM a byl schopen plně komunikovat s Erlang / OTP.
  • Chtěl experimentovat kompilace jiný jazyk na Erlangu. Jako takový viděl LFE jako prostředek, jak to prozkoumat generováním Core Erlang a jeho zapojením do backendu kompilátoru Erlang.

Funkce

Syntaxe a sémantika

Symbolické výrazy (S-výrazy)

Stejně jako Lisp je i LFE výraz -oriented language. Na rozdíl odhomoikonický programovací jazyky, Lisps nečiní žádný nebo jen malý syntaktický rozdíl mezi nimi výrazy a prohlášení: veškerý kód a data jsou zapsána jako výrazy. LFE přinesl do Erlang VM homoiconicitu.

Seznamy

V LFE je datový typ seznamu zapsán tak, že jeho prvky jsou odděleny mezerami a jsou obklopeny závorkami. Například, (seznam 1 2 'foo) je seznam, jehož prvky jsou celá čísla 1 a 2a atom foo. Tyto hodnoty jsou implicitně zadány: jedná se o dvě celá čísla a datový typ specifický pro Lisp, který se nazývá a symbolický atoma nemusí být takto deklarováno.

Jak je vidět v příkladu výše, výrazy LFE se zapisují jako seznamy pomocí prefixový zápis. První prvek v seznamu je název a formulář, tj. funkce, operátor nebo makro. Zbývající část seznamu jsou argumenty.

Operátoři

Operátory LFE-Erlang se používají stejným způsobem. Výraz

 (* (+ 1 2 3 4 5 6) 2)

vyhodnotí na 42. Na rozdíl od funkcí v Erlangu a LFE jsou aritmetické operátory v Lispu variadic (nebo n-ary), schopný přijmout libovolný počet argumentů.

Lambda výrazy a definice funkce

LFE má lambda, stejně jako Common Lisp. Také však má lambda-match zohlednit schopnosti Erlangu porovnávat vzory v anonymních voláních funkcí.

Erlangové idiomy v LFE

Tato část nepředstavuje úplné srovnání mezi Erlang a LFE, ale měla by ochutnat.

Porovnávání vzorů

Erlang:

      1> {Len,Postavení,Zpráva} = {8,OK,„Trillian“}.      {8,OK,„Trillian“}      2> Zpráva.      „Trillian“

LFE:

      > (soubor (n-tice len postavení zpráva) #(8 OK „Trillian“))      #(8 OK „Trillian“)      > zpráva      „Trillian“

Seznam porozumění

Erlang:

      1> [trunc(matematika:prášek(3,X)) || X <- [0,1,2,3]].      [1,3,9,27]

LFE:

      > (list-comp          ((<- X '(0 1 2 3)))          (trunc (matematika: pow 3 X)))      (1 3 9 27)

Nebo idiomatický funkční styl:

      > (seznamy: mapa          (lambda (X) (trunc (matematika: pow 3 X)))          '(0 1 2 3))      (1 3 9 27)

Stráže

Erlang:

      pravé_číslo(X) když X == 42; X == 276709 ->      skutečný;      pravé_číslo(_) ->      Nepravdivé.

LFE:

      (defun správné číslo?        ((X) (když (nebo jinak (== X 42) (== X 276709)))          'skutečný)        ((_) 'Nepravdivé))

s ohledem na funkční hlavy

Erlang:

      součet(L) -> součet(L,0).      součet([], Celkový) -> Celkový;      součet([H|T], Celkový) -> součet(T, H+Celkový).

LFE:

      (defun součet (l) (součet l 0))      (defun součet        (('() celkový) celkový)        (((nevýhody h t) celkový) (součet t (+ h celkový))))

nebo pomocí literálu `` cons`` namísto formuláře konstruktoru:

      (defun součet (l) (součet l 0))      (defun součet        (('() celkový) celkový)        ((`(,h . ,t) celkový) (součet t (+ h celkový))))

Odpovídající záznamy ve funkčních hlavách

Erlang:

handle_info(ping, #Stát {remote_pid = nedefinováno} = Stát) ->    gen_server:obsazení(já(), ping),    {bez odpovědi, Stát};handle_info(ping, Stát) ->    {bez odpovědi, Stát};

LFE:

(defun handle_info  ((ping (= (stav shody remote-pid 'undefined) Stát))    (gen_server: obsazení (já) ping)    `#(bez odpovědi ,Stát))  ((ping Stát)   `#(bez odpovědi ,Stát)))

Příjem zpráv

Erlang:

      univerzální_server() ->          dostávat              {stát se, Func} ->                  Func()          konec.

LFE:

      (defun univerzální server ()        (dostávat          ((n-tice 'stát se func)           (funcall func))))

nebo:

      (defun univerzální server ()        (dostávat          (`#(stát se ,func)            (funcall func))))

Příklady

Erlang interoperabilita

Volání funkcí Erlang mají podobu (: ... ):

(io: formát "Ahoj světe!")

Funkční paradigma

Pomocí rekurze definujte Ackermannova funkce:

(defun ackermann  ((0 n) (+ n 1))  ((m 0) (ackermann (- m 1) 1))  ((m n) (ackermann (- m 1) (ackermann m (- n 1)))))

Funkce skládání:

(defun komponovat (F G)  (lambda (X)   (funcall F     (funcall G X))))(defun šek ()  (nechat* ((hřích-asin (komponovat #'hřích / 1 #'asin / 1))         (očekávaný (hřích (jako v 0.5)))         (výsledek skládání (funcall hřích-asin 0.5)))    (io: formát „Očekávaná odpověď: ~ p ~ n“ (seznam očekávaný))    (io: formát "Odpovědět s napsáním: ~ p ~ n" (seznam výsledek skládání))))

Konkurence

Předávání zpráv s lehkými „procesy“ společnosti Erlang:

(defmodule posel zpět (vývozní (výsledek tisku 0) (poslat zprávu 2)))(defun výsledek tisku ()  (dostávat    ((n-tice pid zpráva)      (io: formát "Přijatá zpráva: '~ s' ~ n" (seznam zpráva))      (io: formát "Odesílání zprávy ke zpracování ~ p ... ~ n" (seznam pid))      (! pid (n-tice zpráva))      (výsledek tisku))))(defun poslat zprávu (volající zpráva)  (nechat ((plodil-pid (potěr 'posel zpět 'výsledek tisku ())))    (! plodil-pid (n-tice volající zpráva))))

Několik současných požadavků HTTP:

(defun parse-args (vlajka)  "Vzhledem k jednomu nebo více argumentům příkazového řádku extrahujte předané hodnoty.  Například pokud bylo prostřednictvím příkazového řádku předáno následující:    $ erl -my-flag moje hodnota-1 -my-vlajka moje hodnota-2  Dalo by se to pak extrahovat v programu LFE voláním této funkce:    (let ((args (parse-args 'my-flag))))      ...      )  V tomto příkladu by hodnota přiřazená proměnné arg byla seznamem  obsahující hodnoty my-value-1 a my-value-2. "  (nechat ((`#(OK ,data) (init: get_argument vlajka)))    (seznamy: sloučit data)))(defun get-stránky ()  "Bez argumentu, předpokládejme, že parametr 'url byl předán příkazovým řádkem."  (nechat ((adresy URL (parse-args „url)))    (get-stránky adresy URL)))(defun get-stránky (adresy URL)  "Spusťte inety a udělejte (potenciálně mnoho) požadavků HTTP."  (inety: začátek)  (seznamy: mapa    (lambda (X)      (získat stránku X)) adresy URL))(defun získat stránku (url)  "Vytvořit jeden požadavek HTTP."  (nechat* ((metoda 'dostat)         (záhlaví '())         (data požadavku `#(,url ,záhlaví))         (možnosti http ())         (možnosti požadavku '(#(synchronizace Nepravdivé))))    (httpc: požadavek metoda data požadavku možnosti http možnosti požadavku)    (dostávat      (`#(http #(,ID požadavku #(chyba ,důvod)))       (io: formát "Chyba: ~ p ~ n" `(,důvod)))      (`#(http #(,ID požadavku ,výsledek))       (io: formát "Výsledek: ~ p ~ n" `(,výsledek))))))

Reference

  1. ^ Virding, Robert. „Lisp ochucený Erlang“ (PDF). Erlang Factory. Citováno 2014-01-17.
  2. ^ A b C „Historie LFE v seznamu adresátů Erlang s příchutí Lisp“. Citováno 2014-05-28.
  3. ^ „Oznámení LFE na seznamu adres Erlang Questions“. Citováno 2014-01-17.
  4. ^ A b Armstrong, Joe; Virding, Robert (30.12.2013). „Hardware používaný při vývoji Erlang a LFE“ (Výměna e-mailů). Rozhovor s Duncanem McGreggorem. Citováno 2014-01-17.
  5. ^ „Opatření v návaznosti na oznámení LFE v seznamu adres Erlang Questions“. Citováno 2014-01-17.

externí odkazy