एलएफई (प्रोग्रामिंग भाषा)

LFE

Paradigm	Multi-paradigm: concurrent, functional
परिवार	Erlang, Lisp
द्वारा डिज़ाइन किया गया	Robert Virding
Developer	Robert Virding
पहली प्रस्तुति	2008 (2008)
Stable release	2.0.1 / 27 June 2021 (2021-06-27)
टाइपिंग अनुशासन	dynamic, strong
कार्यान्वयन भाषा	Erlang
प्लेटफॉर्म	IA-32, x86-64
ओएस	Cross-platform
लाइसेंस	Apache 2.0
फ़ाइल नाम एक्सटेंशनएस	.lfe .hrl
वेबसाइट	lfe.io
Influenced by
Erlang, Common Lisp, Maclisp, Scheme, Elixir, Clojure, Hy
Influenced
Joxa, Concurrent Schemer

लिस्प फ्लेवर्ड एरलांग (एलएफई) एक फंक्शनल भाषा, समवर्ती कंप्यूटिंग, गार्बेज कलेक्टेड (कंप्यूटर विज्ञान), सामान्य प्रयोजन प्रोग्रामिंग भाषा और कोर एरलांग और एरलांग वर्चुअल मशीन (बीईएएम) पर निर्मित लिस्प बोली है। एलएफई वितरित, दोष-सहिष्णु, नरम वास्तविक समय, नॉन-स्टॉप अनुप्रयोगों को लिखने के लिए लिस्प सिंटैक्स प्रदान करने के लिए एरलांग पर बनाता है। एलएफई लिस्प मैक्रोज़ के साथ मेटाप्रोग्रामिंग और फीचर-रिच रीड-इवल-प्रिंट पाश (आरईपीएल) के साथ एक बेहतर विकासक अनुभव का समर्थन करने के लिए एर्लैंग का भी विस्तार करता है। एलएफई को एरलांग की सभी नवीन विमोचन पर सक्रिय रूप से समर्थन प्राप्त है; एर्लैंग समर्थित सबसे पुराना संस्करण R14 है।

इतिहास

रॉबर्ट विर्डिंग

प्रारंभिक विमोचन

एलएफई पर प्रारंभिक कार्य 2007 में प्रारम्भ हुआ, जब रॉबर्ट विर्डिंग ने एर्लांग पर चलने वाले लिस्प का एक प्रोटोटाइप बनाना प्रारम्भ किया। यह कार्य मुख्य रूप से विश्लेषण और यह पता लगाने पर केंद्रित था कि कार्यान्वयन कैसा दिख सकता है। उस समय किसी भी संस्करण नियंत्रण प्रणाली का उपयोग नहीं किया जा रहा था, इसलिए सटीक प्रारंभिक तिथियों को पट्ट करना कुछ हद तक समस्याग्रस्त है।

विर्डिंग ने मार्च 2008 में एर्लांग प्रश्न मेल सूची पर एलएफई की पहली विमोचन की घोषणा की। एलआईएफई की यह विमोचन बहुत सीमित थी: यह पुनरावर्ती letrec s, binary s, receive, या try को संभाल नहीं पाई; यह लिस्प शेल का भी समर्थन नहीं करता था।

एलएफई का प्रारंभिक विकास डेल एक्सपीएस लैपटॉप पर एर्लैंग के संस्करण आर12बी-0 के साथ किया गया था।

उद्देश्य

रॉबर्ट विर्डिंग ने कहा है कि एलएफई प्रोग्रामिंग भाषा प्रारम्भ करने के कई कारण थे:

• उन्हें लिस्प में प्रोग्रामिंग का पूर्व अनुभव था।
• अपने पूर्व अनुभव को देखते हुए, वह अपना स्वयं का लिस्प लागू करने में रुचि रखते थे।
• विशेष रूप से, वह एरलांग में एक लिस्प को लागू करना चाहता था: न केवल वह यह देखने के लिए उत्सुक था कि यह कैसे चलेगा और एरलांग के साथ एकीकृत होगा, वह यह भी देखना चाहता था कि यह कैसा दिखेगा।
• एर्लांग प्रोग्रामिंग भाषा बनाने में मदद करने के बाद से, उनका लक्ष्य एक लिस्प बनाना था जो विशेष रूप से बीईएएम पर चलने के लिए अभिकल्पित किया गया था और एर्लांग/ओटीपी के साथ पूरी तरह से बातचीत करने में सक्षम था।
• वह एर्लैंग पर दूसरी भाषा संकलक के साथ प्रयोग करना चाहते थे। इस प्रकार, उन्होंने एलएफई को कोर एरलांग उत्पन्न करके और इसे एरलांग संकलनकर्ता के बैकएंड में प्लग करके इसका पता लगाने के साधन के रूप में देखा था।

विशेषताएँ

• एर्लांग (प्रोग्रामिंग भाषा) वर्चुअल मशीन (बीईएएम) को लक्षित करने वाली एक भाषा
• निर्बाध एरलांग (प्रोग्रामिंग भाषा) एकीकरण: शून्य-दंड एरलांग फलन आवाहन (और इसके विपरीत)
• लिस्प मैक्रोज़ के माध्यम से मेटाप्रोग्रामिंग और लिस्प की समरूपता
• स्रोत कोड टिप्पणी (कंप्यूटर प्रोग्रामिंग) और डॉकस्ट्रिंग्स दोनों के माध्यम से सामान्य लिस्प-शैली प्रलेखन
• संदेश पासिंग के माध्यम से साझा-कुछ भी नहीं वास्तुकला समवर्ती प्रोग्रामिंग (एक्टर मॉडल)
• साइड-इफेक्ट-आधारित लूप (कंप्यूटिंग) के स्थान पर रिकर्सन (कंप्यूटर विज्ञान) और उच्च-क्रम के कार्यों पर जोर देता है
• पारस्परिक विकास और परीक्षण के लिए एक पूर्ण रीड-इवल-प्रिंट लूप (आरईपीएल) (एरलांग के शेल के विपरीत, एलएफई आरईपीएल फलन और मैक्रो परिभाषाओं का समर्थन करता है)
• प्रतिरूप मिलान
• कोड की हॉट लोडिंग
• लिस्प-1 बनाम लिस्प-2 परिवर्त्य और फलन के लिए नेमस्पेस को अलग करना
• जावा (प्रोग्रामिंग भाषा) जेइंटरफेस और एरजांग के माध्यम से इंटर-ऑपरेशन
• दोनों के साथ स्क्रिप्टिंग भाषा क्षमताएं LFE और lfescript

वाक्य-विन्यास और शब्दार्थ

प्रतीकात्मक अभिव्यक्ति (एस-अभिव्यक्ति)

लिस्प की तरह, एलएफई एक अभिव्यक्ति (कंप्यूटर विज्ञान)-उन्मुख भाषा है। गैर-होमोइकोनिकिटी प्रोग्रामिंग भाषाओं के विपरीत, लिस्प्स अभिव्यक्ति और कथन (प्रोग्रामिंग) के बीच कोई या बहुत कम वाक्यविन्यास भेद नहीं करते हैं: सभी कूट और डेटा अभिव्यक्ति के रूप में लिखे जाते हैं। एलएफई ने एर्लांग वीएम में समरूपता लाई।

सूचियाँ

एलएफई में, सूची डेटा प्रकार को उसके तत्वों के साथ रिक्त स्थान से अलग करके और कोष्ठक से घिरा हुआ लिखा जाता है। उदाहरण के लिए, (list 1 2 'foo) एक सूची है जिसके तत्व पूर्णांक 1 और 2 हैं, और परमाणु फू|foo. ये मान अंतर्निहित रूप से मुद्रलेखन किए गए हैं: वे क्रमशः दो पूर्णांक और एक लिस्प-विशिष्ट डेटा प्रकार हैं जिन्हें प्रतीकात्मक परमाणु कहा जाता है, और उन्हें इस तरह घोषित करने की आवश्यकता नहीं है।

जैसा कि ऊपर दिए गए उदाहरण में देखा गया है, एलएफई अभिव्यक्तियों को उपसर्ग संकेतन का उपयोग करके सूचियों के रूप में लिखा जाता है। सूची में पहला तत्व एक विधि का नाम है, यानी, एक फलन, संचालक, या मैक्रो है। सूची के शेष भाग तर्क हैं।

संचालक

एलएफई-ईआरएलएएनजी संचालक का उपयोग उसी तरह किया जाता है। अभिव्यक्ति

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

42 का मूल्यांकन करता है। एर्लांग और एलएफई में फलन के विपरीत, लिस्प में अंकगणित संचालक विविध फलन (या एन-एरी) हैं, जो किसी भी संख्या में तर्क लेने में सक्षम हैं।

लैम्ब्डा अभिव्यक्ति और फलन परिभाषा

एलएफई में कॉमन लिस्प की तरह ही लैम्ब्डा है। हालाँकि, इसमें अनाम फलन कॉल में एर्लैंग की प्रतिरूप-मिलान क्षमताओं को ध्यान में रखते हुए लैम्ब्डा-मिलान भी है।

एलएफई में एर्लांग मुहावरे

यह खंड एर्लांग और एलएफई के बीच पूर्ण तुलना का प्रतिनिधित्व नहीं करता है, लेकिन इसे एक अनुभव देना चाहिए।

प्रतिरूप मिलान

एरलांग:

      1> {Len,Status,Msg} = {8,ok,"Trillian"}.
      {8,ok,"Trillian"}
      2> Msg.
      "Trillian"

एलएफई:

      > (set (tuple len status msg) #(8 ok "Trillian"))
      #(8 ok "Trillian")
      > msg
      "Trillian"

सूची समझ

एरलांग:

      1> [trunc(math:pow(3,X)) || X <- [0,1,2,3]].
      [1,3,9,27]

एलएफई:

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

या इडिओमाटिक फंक्शनल शैली:

      > (lists:map
          (lambda (x) (trunc (math:pow 3 x)))
          '(0 1 2 3))
      (1 3 9 27)

गार्ड

एरलांग:

      right_number(X) when X == 42; X == 276709 ->
        true;
      right_number(_) ->
        false.

एलएफई:

      (defun right-number?
        ((x) (when (orelse (== x 42) (== x 276709)))
          'true)
        ((_) 'false))

फलन शीर्षों में सहमति

एरलांग:

      sum(L) -> sum(L,0).
      sum([], Total) -> Total;
      sum([H|T], Total) -> sum(T, H+Total).

एलएफई:

      (defun sum (l) (sum l 0))
      (defun sum
        (('() total) total)
        (((cons h t) total) (sum t (+ h total))))

या कंस्ट्रक्टर प्रपत्र के स्थान पर ``cons`` शाब्दिक का उपयोग करना:

      (defun sum (l) (sum l 0))
      (defun sum
        (('() total) total)
        ((`(,h . ,t) total) (sum t (+ h total))))

फलन शीर्षों में अभिलेख मिलान

एरलांग:

handle_info(ping, #state {remote_pid = undefined} = State) ->
    gen_server:cast(self(), ping),
    {noreply, State};
handle_info(ping, State) ->
    {noreply, State};

एलएफई:

(defun handle_info
  (('ping (= (match-state remote-pid 'undefined) state))
    (gen_server:cast (self) 'ping)
    `#(noreply ,state))
  (('ping state)
   `#(noreply ,state)))

संदेश प्राप्त करना

एरलांग:

      universal_server() ->
          receive
              {become, Func} ->
                  Func()
          end.

एलएफई:

      (defun universal-server ()
        (receive
          ((tuple 'become func)
           (funcall func))))

या:

      (defun universal-server ()
        (receive
          (`#(become ,func)
            (funcall func))))

उदाहरण

एर्लैंग अंतरप्रचालनीयता

एर्लांग फलन के लिए कॉल स्वरुप लेते हैं (<मॉड्यूल>:<फलन> <arg1> ... <argn>):

(io:format "Hello, World!")

फंक्शनल प्रतिमान

एकरमैन फलन को परिभाषित करने के लिए रिकर्सन का उपयोग करना:

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

रचना कार्य:

(defun compose (f g)
  (lambda (x)
   (funcall f
     (funcall g x))))

(defun check ()
  (let* ((sin-asin (compose #'sin/1 #'asin/1))
         (expected (sin (asin 0.5)))
         (compose-result (funcall sin-asin 0.5)))
    (io:format "Expected answer: ~p~n" (list expected))
    (io:format "Answer with compose: ~p~n" (list compose-result))))

समवर्ती

एरलांग की हल्की-फुल्की प्रक्रियाओं के साथ संदेश भेजना:

(defmodule messenger-back
 (export (print-result 0) (send-message 2)))

(defun print-result ()
  (receive
    ((tuple pid msg)
      (io:format "Received message: '~s'~n" (list msg))
      (io:format "Sending message to process ~p ...~n" (list pid))
      (! pid (tuple msg))
      (print-result))))

(defun send-message (calling-pid msg)
  (let ((spawned-pid (spawn 'messenger-back 'print-result ())))
    (! spawned-pid (tuple calling-pid msg))))

एकाधिक एक साथ एचटीटीपी अनुरोध:

(defun parse-args (flag)
  "Given one or more command-line arguments, extract the passed values.

  For example, if the following was passed via the command line:

    $ erl -my-flag my-value-1 -my-flag my-value-2

  One could then extract it in an LFE program by calling this function:

    (let ((args (parse-args 'my-flag)))
      ...
      )
  In this example, the value assigned to the arg variable would be a list
  containing the values my-value-1 and my-value-2."
  (let ((`#(ok ,data) (init:get_argument flag)))
    (lists:merge data)))

(defun get-pages ()
  "With no argument, assume 'url parameter was passed via command line."
  (let ((urls (parse-args 'url)))
    (get-pages urls)))

(defun get-pages (urls)
  "Start inets and make (potentially many) HTTP requests."
  (inets:start)
  (plists:map
    (lambda (x)
      (get-page x)) urls))

(defun get-page (url)
  "Make a single HTTP request."
  (let* ((method 'get)
         (headers '())
         (request-data `#(,url ,headers))
         (http-options ())
         (request-options '(#(sync false))))
    (httpc:request method request-data http-options request-options)
    (receive
      (`#(http #(,request-id #(error ,reason)))
       (io:format "Error: ~p~n" `(,reason)))
      (`#(http #(,request-id ,result))
       (io:format "Result: ~p~n" `(,result))))))

बाहरी संबंध

• Official website
• एलएफई on GitHub
• एलएफई क्विक स्टार्ट
• एलएफई यूजर गाइड
• एलएफई ऑन रोसेटा कोड