1 Going Plaid
This is a quick-start, a blur of color. You're not going to get very many details here, but you will get to jump into the LFE REPL and see a little code in action.
For those that would enjoy a more gradual introduction (with a bit more Erlang) thus having the time to see the stars (and not just stunning plaid), you may be interested in checking out the User Guide.
1.1 About LFE
LFE, or "Lisp Flavored Erlang", is a Lisp-2 (similar to Common Lisp in that way) that runs on top of the Erlang VM or "BEAM". Started in 2007 and first release in 2008, it is the oldest sibling in the BEAM language family (the others include Elixir, Joxa, Luerl, Erlog, Haskerl, etc.).
As a Lisp-2, LFE has different namespaces for functions and variables. This
means you can have a function name
help and a variable named
and they won't conflict. Furthermore, LFE has Erlang's notion of arity, so
functions with different arity may share the same name. So you could have
help that took one argument and another function with the
same name that took two arguments, and they wouldn't conflict either.
1.2 Many Paths, One Flavour
Before we jump into LFE, though, you'll need to get it. That can be any of many ways, but we'll highlight a few:
- Homebrew for Mac OS X and Linux
- The ultra-fast and easy way (using Docker), or
- The standard way of setting up dependencies and getting the source.
If you are a Homebrew user -- available for both Mac OS X and Linux -- installing LFE is as simple as a single command:
$ brew install lfe
When the pouring is done, you'll have LFE brewed and ready to savour.
1.2.2 Using Docker
If you choose to run LFE in Docker, you can execute the commands below and then skip to the next section, since you'll be done here!
Docker is not only available on Linux, but runs on Windows and Mac OS X (using the boot2docker tool). Getting Docker set up is beyond the scope of this guide, but once you do, getting LFE is just this simple:
$ docker pull lfex/opensuse
Then you'll need to wait for the download to finish.
In the last command, we asked for the openSUSE LFE image, but there are several to choose from on Docker Hub:
- Arch Linux
- Oracle Linux
The smallest image is Debian's, so that would likely be the fastest download.
Whichever one you choose, you'll need to use the
lfex/* name you see
on the Docker Hub page linked above.
We'll continue with openSUSE.
Once your LFE Docker image download is completed, you can then start up LFE:
$ docker run -i -t lfex/opensuse lfe
And that's it! You will be running an LFE REPL :-D
You're ready for the next page. (Feel free to read the rest of this one, though!)
1.2.3 From Source
If you decide to take the "from source" path, you'll be cloning the LFE github repo. First, through, you'll need to ensure you have some software installed on your system.
First and foremost, you will need Erlang installed.
- On Mac OS X, this is as easy as executing
brew install erlang
- On Ubuntu
apt-get install erlang.
For those who have the need of installing multiple versions of Erlang, there is also the kerl project.
In order to use LFE, you will be calling
make to compile it. To cover your
bases, you'll want to make sure you have the basic development tools installed
for your platform.
$ sudo apt-get install build-essential
$ sudo yum groupinstall "Development Tools"
For Mac OS X, you will need to install the "Developer Tools" from the AppStore.
You will also need
git to continue with this quick-start. If
git doesn't come installed on your system and it wasn't installed as part of your systems basic development tools package, you can download it here
or install it using your favourite OS package manager.
The most recent version of LFE is always available here:
erl in your
$PATH, let's download LFE:
$ git clone https://github.com/rvirding/lfe.git $ cd lfe $ make
You'll see the output from LFE getting built, and when it's done, we're ready for the next step in our Lispy Space Adventure!
But first, a message from our sponsors ...
1.3 Other Helpful Projects
rebar3 is a tool for managing BEAL-language project dependencies, compiling them, and
compiling your project's source code. Many recent Erlang projects have a
rebar.config file in them, indicating their support of
If you would like to easily have multiple versions of Erlang installed (or be
available for installation) on your system,
kerl might be the tool for you. If
you have used such tools as
virtualenv in Python or Ruby's RVM, then you
should be quite comfortable with the concepts behind kerl.
Most people don't need to work with multiple versions of Erlang, however; please consider carefully before unnecessarily complicating your development environment.
Ready for some LFE? Next you'll learn how to create a new LFE project with just one command ...