## Home

When you program, you spend more time reading code than writing it... a language that makes source code ugly is maddening to an exacting programmer, as clay full of lumps would be to a sculptor. - Paul Graham

The goal of this "Readable Lisp s-expressions" project is to develop, implement, and gain widespread adoption of more readable format(s) for the S-expressions of Lisp-based languages (such as Common Lisp, Scheme, Emacs Lisp, and Arc).

The [Problem] is that traditional Lisps don't support infix notation, don't support the standard math notation f(...), and require an excessive number of parentheses. Our [Solution] has three tiers that add additional abbreviations to existing Lisp readers. Put briefly:

1. Curly-infix-expressions (c-expressions): Lists surrounded by {...} are interpreted as infix notation, in a Lispy way. For example, {a + b} represents (+ a b).
2. Neoteric-expressions (n-expressions): An e(...) is interpreted as (e ...), an e{...} is interpreted as (e {...}). For example, sin(x) represents (sin x).
3. Sweet-expressions (t-expressions): Parentheses are deduced from indentation:
• An indented line is a parameter of its parent.
• Later terms on a line are parameters of the first term.
• A line with exactly one term and no child lines is simply that term.
• Empty lines end the previous expression. Just type ENTER ENTER to execute what you've typed.

These are just additional abbreviations - normally-formatted s-expressions continue to work correctly.

You do not need to use all three tiers. You could use neoteric-expressions, for example, which automatically include c-expressions.

Here's one of our [Examples] of sweet-expressions (the top notation tier):

(Awkward) S-expression (Improved) Sweet-expression
(define (factorial n)
(if (<= n 1)
1
(* n (factorial (- n 1)))))
define factorial(n)
if {n <= 1}
1
{n * factorial{n - 1}}

# User information

• [Problem] - more information on the problem we're trying to solve
• [Solution] - a more detailed description of our solution
• SRFI-105 - a formal request to implement our infix notation, for Scheme. Note that guile now includes this.
• SRFI-110 - a formal request to implement our sweet-expression (indentation) format, for Scheme.
• [Install-howto] - how to install it
• [Scheme-tutorial] - a tutorial on how to try it out (Scheme-focused)
• [Common-lisp-tutorial] - a tutorial on how to try it out (Common-Lisp-focused)
• [Style] - style guide for using them
• [Examples] - examples of code using these formats
• [Prepackaged] - list of (some) places where these are pre-packaged
• [Home] - Readable Lisp project's Wiki home

# Philosophy behind the Readable project

• [Hubris] - we are heretically bucking Lisp traditional syntax
• [Goals] - what we want to achieve in this project
• [Rationale] - why we chose what we did in our [Solution]
• [Retort] - a retort to the critics who claim that this can't be done
• [Analysis] - an analysis of our notations, trying them out in different Lisps

The "releases" (files) area distributes our software releases for download. The README describes how to install them; they install using usual conventions and include documentation. This reflects the latest version on the "master" branch.

Our draft (development) code is in the readable code git repository "develop" branch; see [Workflow] for information on our workflow. The easy way to start contributing code is to select the "develop" branch (not the "master" branch) and fork it; when you're done, submit a push request. If you want to get the development code using the command line, and give it a go, do this: