LFE (programming language)

<h2 id="history">History</h2>

<h3>Initial release</h3>
<p>Initial work on LFE began in 2007, when Robert Virding started creating a prototype of Lisp running on Erlang.<a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a> This work was focused primarily on parsing and exploring what an implementation might look like. No version control system was being used at the time, so tracking exact initial dates is somewhat problematic.<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a>
</p><p>Virding announced the first release of LFE on the <i>Erlang Questions</i> mail list in March 2008.<a class="footnote-ref" id="fnref:4" href="#fn:4"><sup>4</sup></a> This release of LFE was very limited: it did not handle recursive letrecs, binarys, receive, or try; it also did not support a Lisp shell.<a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a>
</p><p>Initial development of LFE was done with version R12B-0 of Erlang<a class="footnote-ref" id="fnref:6" href="#fn:6"><sup>6</sup></a> on a Dell XPS laptop.<a class="footnote-ref" id="fnref:7" href="#fn:7"><sup>7</sup></a>
</p>

<h3>Motives</h3>
<p>Robert Virding has stated that there were several reasons why he started the LFE programming language:<a class="footnote-ref" id="fnref:8" href="#fn:8"><sup>8</sup></a>
</p>
<ul><li>He had prior experience programming in Lisp.</li>
<li>Given his prior experience, he was interested in implementing his own Lisp.</li>
<li>In particular, he wanted to implement a Lisp in Erlang: not only was he curious to see how it would run on and integrate with Erlang, he wanted to see what it would <i>look</i> like.</li>
<li>Since helping to create the Erlang programming language, he had had the goal of making a Lisp which was specifically designed to run on the BEAM and able to fully interact with Erlang/OTP.</li>
<li>He wanted to experiment with <a href="/facts/Compiler/WNfCDFJe">compiling</a> another language on Erlang. As such, he saw LFE as a means to explore this by generating Core Erlang and plugging it into the backend of the Erlang compiler.</li></ul>
<h2 id="features">Features</h2>
<ul><li>A language targeting <a href="/facts/Erlang_(programming_language)/2PuxmzT3">Erlang</a> virtual machine (BEAM)</li>
<li>Seamless <a href="/facts/Erlang_(programming_language)/2PuxmzT3">Erlang</a> integration: zero-penalty Erlang function calls (and vice versa)</li>
<li>Metaprogramming via <a href="/facts/Lisp_macro/7abAsm1o">Lisp macros</a> and the <a href="/facts/Homoiconicity/jNG51mrs">homoiconicity</a> of a Lisp</li>
<li><a href="/facts/Common_Lisp/mq1pRbSF">Common Lisp</a>-style documentation via both source code <a href="/facts/Comment_(computer_programming)/Q8hHFq8h">comments</a> and docstrings</li>
<li><a href="/facts/Shared-nothing_architecture/EXvXTQ6E">Shared-nothing architecture</a> concurrent programming via message passing (<a href="/facts/Actor_model/MJ49opnU">Actor model</a>)</li>
<li>Emphasis on <a href="/facts/Recursion_(computer_science)/2uXo18Gv">recursion</a> and <a href="/facts/Higher-order_function/VjnjGbpt">higher-order functions</a> instead of <a href="/facts/Side-effect_(computer_science)/AU3GlLzG">side-effect</a>-based <a href="/facts/Loop_(computing)/2XTDfErC">looping</a></li>
<li>A full <a href="/facts/Read%E2%80%93eval%E2%80%93print_loop/lddjCYxt">read–eval–print loop</a> (REPL) for interactive development and testing (unlike Erlang's shell, the LFE REPL supports function and macro definitions)</li>
<li><a href="/facts/Pattern_matching/CEwptMs9">Pattern matching</a></li>
<li>Hot loading of code</li>
<li>A <a href="/facts/Lisp-1_vs._Lisp-2/mq1pRbSF">Lisp-2</a> separation of namespaces for variables and functions</li>
<li><a href="/facts/Java_(programming_language)/9ScgFyAL">Java</a> inter-operation via JInterface and Erjang</li>
<li><a href="/facts/Scripting_language/8pF4ajBL">Scripting</a> abilities with both lfe and lfescript</li></ul>
<h2 id="syntax-and-semantics">Syntax and semantics</h2>
<h3>Symbolic expressions (S-expressions)</h3>
<p>Like Lisp, LFE is an <a href="/facts/Expression_(computer_science)/eRlhoBeN">expression</a>-oriented language. Unlike non-<a href="/facts/Homoiconicity/jNG51mrs">homoiconic</a> programming languages, Lisps make no or little syntactic distinction between <i>expressions</i> and <i><a href="/facts/Statement_(programming)/bEkBufqX">statements</a></i>: all code and data are written as expressions. LFE brought homoiconicity to the Erlang VM.
</p>
<h3>Lists</h3>
<p>In LFE, the list data type is written with its elements separated by whitespace, and surrounded by parentheses. For example, (list 1 2 'foo) is a list whose elements are the integers 1 and 2, and the atom [[foo|foo]]. These values are implicitly typed: they are respectively two integers and a Lisp-specific data type called a <i>symbolic atom</i>, and need not be declared as such.
</p><p>As seen in the example above, LFE expressions are written as lists, using <a href="/facts/Prefix_notation/dUzpf2Ys">prefix notation</a>. The first element in the list is the name of a <i>form</i>, i.e., a function, operator, or macro. The remainder of the list are the arguments.
</p>
<h3>Operators</h3>
<p>The LFE-Erlang operators are used in the same way. The expression
</p>
 (* (+ 1 2 3 4 5 6) 2)

<p>evaluates to 42. Unlike functions in Erlang and LFE, arithmetic operators in Lisp are <a href="/facts/Variadic_function/XjW6Nbsw">variadic</a> (or <i>n-ary</i>), able to take any number of arguments.
</p>
<h3>Lambda expressions and function definition</h3>
<p>LFE has <i>lambda</i>, just like Common Lisp. It also, however, has <i>lambda-match</i> to account for Erlang's pattern-matching abilities in anonymous function calls.
</p>
<h2 id="erlang-idioms-in-lfe">Erlang idioms in LFE</h2>
<p>This section does not represent a complete comparison between Erlang and LFE, but should give a taste.
</p>
<h3>Pattern matching</h3>
<p>Erlang:
</p>
      1> {Len,Status,Msg} = {8,ok,"Trillian"}.
      {8,ok,"Trillian"}
      2> Msg.
      "Trillian"

<p>LFE:
</p>
      lfe> (set (tuple len status msg) #(8 ok "Trillian"))
      lfe> ;; or with LFE literal tuple syntax:
      lfe> (set `#(,len ,status ,msg) #(8 ok "Trillian"))
      #(8 ok "Trillian")
      lfe> msg
      "Trillian"

<h3>List comprehensions</h3>
<p>Erlang:
</p>
      1> [trunc(math:pow(3,X)) || X <- [0,1,2,3]].
      [1,3,9,27]

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

<p>Or idiomatic functional style:
</p>
      lfe> (lists:map
             (lambda (x) (trunc (math:pow 3 x)))
             '(0 1 2 3))
      (1 3 9 27)

<h3>Guards</h3>
<p>Erlang:
</p>
      right_number(X) when X == 42; X == 276709 ->
        true;
      right_number(_) ->
        false.

<p>LFE:
</p>
      (defun right-number?
        ((x) (when (orelse (== x 42) (== x 276709)))
          'true)
        ((_) 'false))

<h3>cons'ing in function heads</h3>
<p>Erlang:
</p>
      sum(L) -> sum(L,0).
      sum([], Total) -> Total;
      sum([H|T], Total) -> sum(T, H+Total).

<p>LFE:
</p>
      (defun sum (l) (sum l 0))
      (defun sum
        (('() total) total)
        (((cons h t) total) (sum t (+ h total))))

<p>or using a ``cons`` literal instead of the constructor form:
</p>
      (defun sum (l) (sum l 0))
      (defun sum
        (('() total) total)
        ((`(,h . ,t) total) (sum t (+ h total))))

<h3>Matching records in function heads</h3>
<p>Erlang:
</p>
handle_info(ping, #state {remote_pid = undefined} = State) ->
    gen_server:cast(self(), ping),
    {noreply, State};
handle_info(ping, State) ->
    {noreply, State};

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

<h3>Receiving messages</h3>
<p>Erlang:
</p>
      universal_server() ->
          receive
              {become, Func} ->
                  Func()
          end.

<p>LFE:
</p>
      (defun universal-server ()
        (receive
          ((tuple 'become func)
           (funcall func))))

<p>or:
</p>
      (defun universal-server ()
        (receive
          (`#(become ,func)
            (funcall func))))

<h2 id="examples">Examples</h2>
<h3>Erlang interoperability</h3>
<p>Calls to Erlang functions take the form <i>(<module>:<function> <arg1> ... <argn>)</i>:
</p>
(io:format "Hello, World!")

<h3>Functional paradigm</h3>
<p>Using recursion to define the <a href="/facts/Ackermann_function/WQNpCWHn">Ackermann function</a>:
</p>
(defun ackermann
  ((0 n) (+ n 1))
  ((m 0) (ackermann (- m 1) 1))
  ((m n) (ackermann (- m 1) (ackermann m (- n 1)))))

<p>Composing functions:
</p>
(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))))

<h3>Concurrency</h3>
<p>Message-passing with Erlang's light-weight "processes":
</p>
(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))))

<p>Multiple simultaneous HTTP requests:
</p>
(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))))))

<h2 id="external-links">External links</h2>
<ul><li><a href="http://lfe.io">Official website</a></li>
<li><a href="https://github.com/rvirding/lfe">LFE</a> on <a href="/facts/GitHub/n1hNCsc3">GitHub</a></li>
<li><a href="https://lfe.gitbooks.io/quick-start/content/index.html">LFE Quick Start</a></li>
<li><a href="https://lfe.gitbooks.io/reference-guide/">LFE User Guide</a></li>
<li><a href="http://rosettacode.org/wiki/Category:LFE">LFE on Rosetta Code</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>Virding, Robert. "Lisp Flavored Erlang" (PDF). Erlang Factory. Retrieved 2014-01-17. <a href="http://www.erlang-factory.com/upload/presentations/61/Robertvirding-LispFlavouredErlang.pdf" target="_blank">http://www.erlang-factory.com/upload/presentations/61/Robertvirding-LispFlavouredErlang.pdf</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>"LFE History on the Lisp Flavored Erlang mail list". Retrieved 2014-05-28. <a href="https://groups.google.com/d/msg/lisp-flavoured-erlang/XA5HeLbQQDk/TUHabZCHXB0J" target="_blank">https://groups.google.com/d/msg/lisp-flavoured-erlang/XA5HeLbQQDk/TUHabZCHXB0J</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>"LFE History on the Lisp Flavored Erlang mail list". Retrieved 2014-05-28. <a href="https://groups.google.com/d/msg/lisp-flavoured-erlang/XA5HeLbQQDk/TUHabZCHXB0J" target="_blank">https://groups.google.com/d/msg/lisp-flavoured-erlang/XA5HeLbQQDk/TUHabZCHXB0J</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
<li id="fn:4"><p>"LFE announcement on Erlang Questions mail list". Retrieved 2014-01-17. <a href="https://groups.google.com/d/msg/erlang-questions/rf43UofUvvQ/2-L1AecnkUoJ" target="_blank">https://groups.google.com/d/msg/erlang-questions/rf43UofUvvQ/2-L1AecnkUoJ</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li>
<li id="fn:5"><p>Armstrong, Joe; Virding, Robert (2013-12-30). "Hardware used in the development of Erlang and LFE" (Email exchange). Interviewed by Duncan McGreggor. Retrieved 2014-01-17. <a href="http://www.erlang.org/course/history.html" target="_blank">http://www.erlang.org/course/history.html</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li>
<li id="fn:6"><p>"Follow-up to LFE announcement on Erlang Questions mail list". Retrieved 2014-01-17. <a href="https://groups.google.com/d/msg/erlang-questions/rf43UofUvvQ/dthHortHwGoJ" target="_blank">https://groups.google.com/d/msg/erlang-questions/rf43UofUvvQ/dthHortHwGoJ</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li>
<li id="fn:7"><p>Armstrong, Joe; Virding, Robert (2013-12-30). "Hardware used in the development of Erlang and LFE" (Email exchange). Interviewed by Duncan McGreggor. Retrieved 2014-01-17. <a href="http://www.erlang.org/course/history.html" target="_blank">http://www.erlang.org/course/history.html</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li>
<li id="fn:8"><p>"LFE History on the Lisp Flavored Erlang mail list". Retrieved 2014-05-28. <a href="https://groups.google.com/d/msg/lisp-flavoured-erlang/XA5HeLbQQDk/TUHabZCHXB0J" target="_blank">https://groups.google.com/d/msg/lisp-flavoured-erlang/XA5HeLbQQDk/TUHabZCHXB0J</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li>
</ol>

LFE (programming language) open-in-new

LFE (programming language)