cl-syntax-sugar

Having a custom syntax may be useful to simplify typing and also to help code readability. Readability is helped by removing unnecessary noise and giving a given construct a distinct visual representation that is easier to be processed by the pattern matcher in our brains (well, mine at least). This projects aims to

• help setting up Slime/ASDF to compile and load files and C-c C-c code blocks with custom syntaxes that are only available in certain packages
• provide a few well known syntaxes out of the box
• provide tools to easily create your own syntax

But I believe that code speaks like a million words, so read on...

You can find a few examples of the supported syntaxes below. The API of each syntax consist of three different entries:

• enable-name-syntax: a macro that copies *READTABLE*, enables the syntax in the copy and stores it back in *READTABLE*. This should be mostly used as a toplevel form in a file (as *READTABLE* is rebound by the compiler, it has no effects outside the file it is used in. It also means that C-c C-c'ing in Slime won't work on forms that use this syntax, unless a proper readtable is registered in Swank).
• set-name-syntax-in-readtable: this function enables the syntax in the current *READTABLE* without copying it.
• with-name-syntax: this can be used with the help of the readtime-wrapper syntax:

  (enable-readtime-wrapper-syntax #\{ #\})
  
  {with-sharp-boolean-syntax
    (and #t
         (or #f
             #t))}
  

The list of available syntaxes at the time of writing with some examples (consult the code and the testsuite for the details):

• The sharp-boolean reader reads #t and #f into CL:T and CL:NIL respectively.
• The readtime-wrapper syntax helps when you want to do something with dynamic scope at read time. For example if you want to enable a reader locally inside a block, or you want to read a block of code into a different package, then you can do something like this:

  CL-SYNTAX-SUGAR-TEST> (enable-readtime-wrapper-syntax #\{ #\})
  ; No value
  CL-SYNTAX-SUGAR-TEST> {(with-package :cl-walker)
                         '(foo bar baz)}
  (CL-WALKER::FOO CL-WALKER::BAR CL-WALKER::BAZ)
  

• The quasi-quote syntax is very similar to the lisp quasi-quote reader installed on #\` #\, and #\@ but it does not do the actual transformation in which the expression is turned into a form which, when evaluated, builds the expected result at runtime. Rather it just lets you define how the quote and unquote fragments should be wrapped at read time. (For real-life usage examples see cl-quasi-quote).

  CL-SYNTAX-SUGAR-TEST> '{(with-quasi-quote-syntax 'my-quote 'my-unquote
                                                   :quasi-quote-character #\[
                                                   :quasi-quote-end-character #\]
                                                   :unquote-character #\,
                                                   :splice-character #\@)
                          [1 2 ,3 ,@`(foo ,(call-bar)) 5]}
  (MY-QUOTE (1 2 (MY-UNQUOTE 3 NIL) (MY-UNQUOTE `(FOO ,(CALL-BAR)) T) 5))
  

• The lambda-with-bang-args syntax helps when you need short lambda's (please note that it's only loaded by asdf-system-connections after you load cl-walker, too):

  CL-SYNTAX-SUGAR-TEST> (set-lambda-with-bang-args-syntax-in-readtable :start-character #\[ :end-character #\])
  ; No value
  CL-SYNTAX-SUGAR-TEST> (funcall [+ !1 40] 2)
  42
  CL-SYNTAX-SUGAR-TEST> (funcall [concatenate 'string !2 "-bar-" !1] "baz" "foo")
  "foo-bar-baz"
  CL-SYNTAX-SUGAR-TEST> (set-lambda-with-bang-args-syntax-in-readtable :dispatch-character #\# :sub-dispatch-character #\L)
  ; No value
  CL-SYNTAX-SUGAR-TEST> (funcall #L(+ !1 40) 2)
  42
  

• The feature-case reader is a read-time COND expression with the following rules:
  • it's body is read into *PACKAGE* (as opposed to the standard #+ and #- readers that read into the "KEYWORD" package)
  • the condition forms are recursively walked and all occurances of keyword symbols are replaced with (find :symbol *features*), but only inside the and/or/not subtree

  CL-SYNTAX-SUGAR-TEST> (set-feature-cond-syntax-in-readtable)
  ; No value
  CL-SYNTAX-SUGAR-TEST> #*(((and :sbcl (stringp 42)) "silly example")
                           (:sbcl "sbcl is my primary lisp")
                           (:clisp "i need threads...")
                           (t "hm, seems like we are neither on sbcl or clisp..."))
  "sbcl is my primary lisp"
  CL-SYNTAX-SUGAR-TEST> 

• cl-syntax-sugar-devel for any discussion about cl-syntax-sugar

You can browse the cl-syntax-sugar darcs repository or get the tree with

darcs get --partial http://common-lisp.net/project/cl-syntax-sugar/darcs/cl-syntax-sugar

BSD / Public Domain