Lamber: Functional scripting language compiling to Lambda Calculus

Lamber is a minimalist functional programming language with a focus on graspability, readability… and compilation to pure untyped Lambda Calculus, of course! It’s inspired by Lua, Haskell, and Wisp. And it smells of creamy cheese!

Step by step:

• You can bind things to names/variables (like factorial) with let, def, local, and var. All of these do the same thing, so pick the one you like the most.
• Functions are all there is to Lamber. It compiles to raw lambdas, after all. It’s only consequential that things you bind to vars are fn-s, lambda-s,a nd function-s.
• There’s if~/~when to do conditional checks. With else branches and else if chaining. Boring stuff, right?
• There’s no need for explicit return statement, because the last form in the function/branch is the return value.
  • So factorial returns either 1 or… wait, I need to explain some more.
• Functions are prefix in Lamber, so = n 0 means “n is equal to zero” and dec n means decreasing n.
• There’s no looping in Lamber, only recursion.
  • Luckily, first-class functions and abundance of list processing utilities in the standard library make explicit looping unnecessary in most cases.
• There are several special syntax pieces, mostly stolen from Wisp:
  • : colon to chain function calls. Lamber emphasizes composable functions that are easy to chain, as in * n : factorial : dec n:
    • Decrease n.
    • Call factorial on it.
    • And multiply the result by n.
  • . period is a shortcut for end (like in Lua and the kind.) You can do explicit end too, but it’s not as pretty:

There’s a number of guiding principles Lamber is built around:

MinimalismIf something is not absolutely necessary, it’s not going to be there. CognitiveAll there is in the language should fit into one moderately overwhelmed programmer’s head. FootprintImplementation should be small enough. BuildAll the libraries and apps are provided as files on CLI or in LAMBER_PATH and sorted lexicographically. Want to load your lib earlier? Just rename the file! SyntacticalThere shouldn’t be more than ten pieces of syntax in the language.

• As of the moment of writing, there are eight:
  • let / def etc. variable definition.
  • if branching.
  • function-s.
  • type-s.
  • Literal values, like booleans, numbers, and strings.
  • Function calls.
  • Colons.
  • Periods.

ReadabilityLambda Calculus is scary. Lua is not. Lamber tries to be somewhere in between the two, with the bias towards Lua. Functional designFunctional programming won, and you have to live with it. Make your functions composable and higher-order. And no side-effects (well, there’s ./lib/8000-io.lmb, but hush!)

• Clone the repo:

• Install a Lisp implementation like SBCL.
• Compile the lamber executable with make all
• Use the generated lamber as in