lfe / lfe.github.io Goto Github PK

The LFE Landing Site / Home Page

HTML 47.02% CSS 16.03% JavaScript 14.33% Makefile 4.94% SCSS 17.48% Dockerfile 0.21%

lfe.github.io's Introduction

LFE

LFE, Lisp Flavoured Erlang, is a lisp syntax front-end to the Erlang compiler. Code produced with it is compatible with "normal" Erlang code. An LFE evaluator and shell is also included.

Building

To compile LFE, simple clone it and compile:

$ git clone https://github.com/lfe/lfe.git
$ cd lfe
$ make compile

LFE requires Erlang be installed on the system and that the erl binary is in $PATH.

Running the Tests

To run the full suite of tests for LFE, simply use the following:

make tests

Installation

Should you wish to have LFE available system-wide, you can run the following make target:

$ make install

By default this will create the programs lfe, lfec, lfedoc and lfescript in /usr/local/bin. This can be changed by defining the make variable PREFIX to point to the desired parent directory.

Note that the install target will also install the LFE man pages in the appropriate $(PREFIX)/share/man/man* directories. This can be changed by defining the make variable MANINSTDIR to point to the desired top man directory.

So:

$ make install PREFIX=/Users/rv/ MANINSTDIR=/Users/rv/man

will put the programs in /Users/rv/bin and the man pages in the /Users/rv/man/man* directories.

REPL

If you're running LFE from a git clone working dir, you can start the REPL like so after compiling:

$ ./bin/lfe

Erlang/OTP 26 [erts-14.0.2] [source] [64-bit] [smp:10:10] [ds:10:10:10] [async-threads:1] [jit] [dtrace]

   ..-~.~_~---..
  (      \\     )    |   A Lisp-2+ on the Erlang VM
  |`-.._/_\\_.-':    |   Type (help) for usage info.
  |         g |_ \   |
  |        n    | |  |   Docs: http://docs.lfe.io/
  |       a    / /   |   Source: http://github.com/lfe/lfe
   \     l    |_/    |
    \   r     /      |   LFE v2.1.4 (abort with ^G)
     `-E___.-'

lfe>

If you have installed LFE, then you may start the REPL from any location:

$ lfe

Likewise, you may run an LFE shell script in the same style as shell scripts with:

$ ./bin/lfe script-name script-arg-1 ...

$ lfe script-name script-arg-1 ...

Usage

The docs site has several places to explore that will show you how to start using LFE. However, here's a quick taste:

start up an LFE REPL as demonstrated above
then, do something like this:

lfe> (* 2 (+ 1 2 3 4 5 6))
42
lfe> (* 2 (lists:foldl #'+/2 0 (lists:seq 1 6)))
42

Docker Support

LFE now supports Docker. To get started, simply do the following, once you have Docker set up on your machine:

$ docker pull lfex/lfe

Alternatively, you could build the image yourself:

$ cd lfe
$ docker build .

To bring up the LFE REPL:

$ docker run -it lfex/lfe

Documentation

Files with more technical details:

If you would like to make changes to the LFE documentation and then regenerate the docs, you'll want to read the instructions here:

Updating LFE Documentation

Join the Community

LFE on Slack, join by requesting an invite here

LFE Forum - Erlang Forums

Maintainers

Cutting Releases

Steps:

Update the version in src/lfe.app.src
Create the release tags
Create a release on Github
Publish to hex.pm

Once the app.src has been updated with the version for the release, you can create and push the tags (to Github) with the following:

make tags

That will create the number-only version as well as the "v"-prefixed version.

For now, the process of creating a release on Github is manual:

Go to https://github.com/lfe/lfe/releases
Click "Draft new release"
Select the correct tag from the drop-down "Choose a tag"
Click "Generate release notes"
Click "Publish release"

Lastly, to publish LFE to hex.pm, you need to have rebar3 installed on our system and an entry for the hex plugin in your system rebar.config file. With that in place, publish a new release to hex.pm requires only the following:

make hex-publish

lfe.github.io's People

Contributors

Stargazers

Watchers

Forkers

hdiedrich mankykitty oubiwann elight macintux kisom sarabander justincampbell jrdnull lpil onobori billosys ryugi nazarsh codelisperer stjordanis panoptisdev john-goff nate-sys

lfe.github.io's Issues

Style Guide: Add Content to 6 Testing

Move mobi-generating code into a module

The script is getting too cumbersome.

Provide a nitrogen tutorial in LFE

http://nitrogenproject.com/doc/index.html

Add embedded html ToC

This is the ToC that's actually part of the book itself

Add cover art to .mobi

Write the mochiweb https example in LFE

https://github.com/mochi/mochiweb/blob/master/examples/https/https_store.erl

Update the function list with the latest from LFE

Robert has added new LFE BIFs; the docs need to reflect this change.

Write the webmachine demo in LFE

https://github.com/basho/webmachine/wiki/Demo

Backquote macro in LFE

This is from an email that Robert sent, and it's a great idea:

I was looking through some of the examples you refer to in the LFE page when I remembered that LFEs backquote macro even works with tuples . So you can use a tuple "pattern" which expands into code to build a tuple. For example:

`#(ok ,reply) ==> (tuple 'ok reply))

With that you could write the callbacks to the ping_pong server as:

(defun init (args)
  `#(ok ,(make-state pings 0)))

(defun handle_call (req from state)
  (let* ((new-count (+ (state-pings state) 1))
         (new-state (set-state-pings state new-count)))
    `#(reply #(pong ,new-count) ,new-state)))

It of course also works in patterns. This is clearer and more concise for those who know about it but I don't think that this is something to drop on the poor unsuspecting reader from the beginning, but a section on the backquote macro would be good to have somewhere.

Add Cookbook

This would be a whole new segment of the site, not just another section.

Add support for pdf file generation

Style Guide: Add Content to 12 Pitfalls

Add OTP Server Tutorial

Add lfetool Book

Create a new site book (like the User Guide, the Cookbook, etc.) that does a thorough job explaining how to use (and maximize the use of) lfetool in developing LFE projects of all types.

Create .mobi files for user guide, each tutorial, etc.

This depends upon issue #2. There should be some command line tools that do this. At the very least, though, I've converted Google Docs (downloaded as HTML) to .mobi using Calibre.

Also, there is a git repo somewhere of SICP that has been set up to generate a .mobi file for that book. There might be some good hints in that repo.

Update list comprehension sections to use new aliases

Java Interop: Finish Erjang Content

Provide a Riak client tutorial in LFE

https://github.com/basho/riak-erlang-client

Add title page to .epub

Create an ETS tutorial

Be sure to include a section about working with a table across processes:

"The table identifier can be sent to other processes so that a table can be shared between different processes within a node."

(from http://www.erlang.org/doc/man/ets.html)

Add more to processes tutorial

processes on multi-core apps
distributed processes

Split out LFE function docs

Right now, there's a listing of functions here:

http://lfe.github.io/user-guide/funcode/2.html

This should be moved to the introductory section, right after the page on data types in LFE.. In its place should be several pages of functions -- description and usage examples for each. What are sections on that page right now should become separate pages.