Wisp: Whitespace to Lisp
========================

    define : hello                    (define (hello)
      display "Hello World"     ⇒        (display "Hello World"))


    define : hello who                 (define (hello who)
      display                 ⇒          (display
        string-append                      (string-append
          . "Hello " who                     "Hello " who)))


    defun a : b c                  (defun a (b c) 
      let                            (let         
        : d e                          ((d e)     
          : f             ⇒             ((f)      
            ' g                          '(g)))   
        h i                          (h i)        
        . j                          j))          


Wisp turns indentation based syntax into Lisp. The conversion is homoiconic[^h], generic[^g], and backwards-compatible[^b]. It is inspired by project readable, but tries to keep itself simple (and stupid: just a preprocessor). More information on the [wisp-website][] and code in the [wisp-repository][].

[wisp-website]: http://draketo.de/light/english/wisp-lisp-indentation-preprocessor
[wisp-repository]: http://draketo.de/proj/wisp


Bootstrap: autoreconf -i && ./configure && make

Usage: guile ./wisp.scm infile.wisp > outfile.lisp

Usage on the REPL (guile shell):

    guile -L . --language=wisp # run this in the wisp-folder

Also see `./wisp-multiline.sh --help`


License: GPLv3 or later.


[^h]: Wisp is homoiconic because everything you write gets turned into lisp which is homoiconic.

[^g]: Wisp is generic, because it works for any language which uses brackets to start a function call - which is true for most lisps. You simply get rid of the speerwall of parentheses without losing their power.

[^b]: Wisp is backwards compatible, because you can simply use arbitrary lisp code in wisp: Indentation processing skipps expressions in brackets.