Unλαmβdα, or GUI (Gothenburg Unlambda Interpreter...)

Almost good Unlambda interpreter, written in Haskell

Unlambda: Your Functional Programming Language Nightmares Come True.

Unlambda is an esoteric programming language, written by David Madore. It is based on the SKI-combinator calculus, a version of the lambda calculus. The syntax consists of the operators S and K (and also I, but it can be written with S and K).

S := λf.λg.λx.f x (g x)
K := λx.λy.x
I := λx.x => λx.skkx

In Unlambda these are written with s, k, i, and application is written with `. This version of the language also supports the "syntactic sugar" operators .x, v, and r (which just prints newline).

Installation

Install it with stack:

$ stack install

Then add ~/.local/bin/ to your path. You can do this most simply by adding this to your bashrc (replacing USER with your username, of course):

export PATH=/home/USER/.local/bin:$PATH

How to Run

In ghci

$ stack ghci src/Run.hs

Then to run strings / .unl files.

*Unλαmβdα> run <ProgramString>*Unλαmβdα> runFile <FilePath>

To parse and format strings / .unl files.

*Unλαmβdα> formatParse <ProgramString>*Unλαmβdα> formatParseFile <FilePath>

Using gui

After installation, run:

$ gui --help

Cheat Sheet

k (“constant generator”)
The k function takes an argument X and returns the function `kX (see below).
`kX (“constant function”)
The `kX function (which is not primitive but obtained by applying the primitive function k to some function X) takes an argument, ignores it and returns X.
s (“substitution”)
The s function takes an argument X and returns the function `sX (see below).
`sX (“substitution first partial”)
The `sX function (which is not primitive but obtained by applying the primitive function s to some function X) takes an argument Y and returns the function ``sXY (see below).
``sXY (“substituted application”)
The ``sXY function (which is not primitive but obtained by applying the primitive function s to two functions X and Y successively) takes an argument Z and returns the evaluation of ``XZ`YZ.
i (“identity”)
The i function takes an argument and returns that argument.
v (“void”)
The v function takes an argument X and returns v itself.
.x (“print”) and r (“carriage return”)
The .x function is written using two characters. The first character is a period and the second is any character. Nevertheless, .x is a single function in Unlambda, and x in this expression is merely a character (read during parsing), not a parameter to the function. The r function is exactly equivalent to .(newline). The .x function behaves like the i (identity) function, with the side effect that it prints the character x (to the standard output) when it is applied. The r function also behaves like the identity and prints a newline character.
r ("return")
Prints a newline, equivalent to (`.'\n'i).

From David Madore's original page: http://www.madore.org/~david/programs/unlambda/.