Function EXpression Language (interpreter for functional programs)
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Type Name Latest commit message Commit time
Failed to load latest commit information.

fexl - Function EXpression Language

Fexl is a simple but powerful scripting language. It allows you to manipulate numbers, strings, streams, and functions easily and reliably, all within a secure "sandbox".

Getting started

Go into the source code directory:

cd src

Build the code and test its validity:


That runs the test/run script and compares its output with the reference output in test/run.out. If everything works as expected, you should see no output. However, if you run on a 32-bit system you will see some inconsequential differences in the output of test/b18.fexl, which measures memory usage, and also test/b17.fexl, which deliberately tries to run out of memory.


There is no "installation" as such. You just put the Fexl code anywhere you like, build it, and run it from there. There is no script to copy it to /usr or anything like that.

My approach is to create a ~/bin/fexl script which does this:

exec ~/project/fexl/bin/fexl "$@"

So the "fexl" script in my search path runs the real executable right where I built it, setting argv[0] to its full path name, allowing it to resolve the names of any files it might need that come bundled with the distribution. That way I don't have to rely on non-portable features like "/proc/self/exe" to locate the executable.

Development Tools

To build the code:


To erase the output files and build the code from scratch:

./build clean

To erase the output files:

./build erase

To do a verbose build, showing all the commands:

verbose=1 ./build

To build the code and run a fexl program:

./fexl [FILE]

To build the code and see the test output:


To build the code and check the test output:


To source the handy shell aliases that I use for development:

. handy

To time the test output:


To time a long series of calculations and output:


To see the current version number (


Guide to source code

The main routine is in fexl.c.

The eval routine is in value.c.

The value structure is defined in value.h, and documented in value.c.

The memory.c file implements a disciplined approach to memory usage which verifies that there are no memory leaks during execution. Also see hold and drop in value.c, which implement the reference counting mechanism.

The "test" directory contains the Fexl test suite.

Technical Details

The interpreter creates an initial value which represents your entire program. It then evaluates that value, reducing it one step at a time until it reaches a final value. Each step may possibly create side effects -- after all, the entire purpose of a computer program is to create side effects. However, the purely functional aspect of Fexl allows you to isolate those side effects as far as you like.

A value is either an atom or a pair. An atom represents either a built-in function (with a pointer to a C function), or a piece of data (e.g. long, double, string, file, etc.) A pair represents the functional application of a value on the left side to a value on the right side.

The initial value is fully resolved and contains no symbols, so the interpreter does not have to do any symbol lookups or bindings during evaluation.


"On the Building Blocks of Mathematical Logic", Moses Schönfinkel, 1924

"Typed Representation of Objects by Functions", Jørgen Steensgaard-Madsen, 1989


This code is copyright 2011 by Patrick Chkoreff ( See the LICENSE file for details.