[PATCH] Clojure-like syntactic sugar for an anonymous function literal

[Oleh <ohwoeowho@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 1474 bytes --]

Hi all,

This is my first attempt of modifying the C source of Emacs.
The goal is to add a new reader syntax:

    #(foo bar) should translate to (short-lambda (foo bar))

This is in the same way that the `backquote' is working now:

    `(foo bar) translates to (backquote (foo bar))

The `short-lambda' macro is implemented here:
https://github.com/abo-abo/short-lambda.

In the simplest form, i.e. one that does not allow multiple or
&rest-style arguments, it can look like this:

    (defmacro short-lambda (x)
      `(lambda (%) ,x))

Even in this simple form, it can sweeten up Elisp a lot:

    (mapc #(put % 'disabled nil)
          '(upcase-region downcase-region narrow-to-region))

With the (less trivial) linked `short-lambda', the following is
possible:

    (cl-mapcar #(concat %1 " are " %2)
               '("roses" "violets")
               '("red" "blue"))

Here's a snippet from `org-mode':

    (mapcar (lambda (x)
              (and (member (car x) matchers) (nth 1 x)))
            org-latex-regexps)

Here's the sweetened code:

    (mapcar #(and (member (car %) matchers) (nth 1 %))
            org-latex-regexps)

As far as I know, only #("foo" ...) literal is already taken, so #(Z,
where Z is anything but a " is up for grabs, reader-wise.

I hope that you don't view this patch as malarkey. Saving a few chars
while typing and reading is a big deal to a lot of people.  And the
way I see it, this implementation doesn't cost much.

regards,
Oleh

[-- Attachment #2: 0001-Modify-reader-.-is-short-lambda.patch --]
[-- Type: text/x-patch, Size: 3436 bytes --]

From a8e0c5418598655bdfdda6d5cb541262a5575927 Mon Sep 17 00:00:00 2001
From: Oleh Krehel <ohwoeowho@gmail.com>
Date: Fri, 9 Jan 2015 08:33:07 +0100
Subject: [PATCH] Modify reader: #([^"]...) is (short-lambda ...)

* src/lread.c (read1): When "#(" is found, check if the next symbol is
  '"'. If it is, continue with the old string syntax. Otherwise, treat
  "#(...)" similar to a backquote, except the symbol name is
  `short-lambda' instead of `backquote'.

The indent is to allow to use "#(+ % %)" in place of
"(lambda (%) (+ % %))".

The simplest implementation:

    (defmacro short-lambda (structure)
      `(lambda (%) ,structure))

It could be easily extended to produce "(lambda (%1 %2) (+ %1 %2))"
from "#(+ %1 %2)".
---
 src/lread.c | 65 +++++++++++++++++++++++++++++++++++--------------------------
 1 file changed, 37 insertions(+), 28 deletions(-)

diff --git a/src/lread.c b/src/lread.c
index 3240524..905164f 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -2671,34 +2671,42 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
 	}
       if (c == '(')
 	{
-	  Lisp_Object tmp;
-	  struct gcpro gcpro1;
-	  int ch;
-
-	  /* Read the string itself.  */
-	  tmp = read1 (readcharfun, &ch, 0);
-	  if (ch != 0 || !STRINGP (tmp))
-	    invalid_syntax ("#");
-	  GCPRO1 (tmp);
-	  /* Read the intervals and their properties.  */
-	  while (1)
-	    {
-	      Lisp_Object beg, end, plist;
-
-	      beg = read1 (readcharfun, &ch, 0);
-	      end = plist = Qnil;
-	      if (ch == ')')
-		break;
-	      if (ch == 0)
-		end = read1 (readcharfun, &ch, 0);
-	      if (ch == 0)
-		plist = read1 (readcharfun, &ch, 0);
-	      if (ch)
-		invalid_syntax ("Invalid string property list");
-	      Fset_text_properties (beg, end, plist, tmp);
-	    }
-	  UNGCPRO;
-	  return tmp;
+          int next_char = READCHAR;
+          UNREAD (next_char);
+          if (next_char == '"') {
+            Lisp_Object tmp;
+            struct gcpro gcpro1;
+            int ch;
+
+            /* Read the string itself.  */
+            tmp = read1 (readcharfun, &ch, 0);
+            if (ch != 0 || !STRINGP (tmp))
+              invalid_syntax ("#");
+            GCPRO1 (tmp);
+            /* Read the intervals and their properties.  */
+            while (1)
+              {
+                Lisp_Object beg, end, plist;
+
+                beg = read1 (readcharfun, &ch, 0);
+                end = plist = Qnil;
+                if (ch == ')')
+                  break;
+                if (ch == 0)
+                  end = read1 (readcharfun, &ch, 0);
+                if (ch == 0)
+                  plist = read1 (readcharfun, &ch, 0);
+                if (ch)
+                  invalid_syntax ("Invalid string property list");
+                Fset_text_properties (beg, end, plist, tmp);
+              }
+            UNGCPRO;
+            return tmp;
+          } else {
+            UNREAD(c);
+            Lisp_Object value = read0 (readcharfun);
+            return list2 (Qshort_lambda, value);
+          }
 	}
 
       /* #@NUMBER is used to skip NUMBER following bytes.
@@ -4731,6 +4739,7 @@ that are loaded before your customizations are read!  */);
   DEFSYM (Qcomma, ",");
   DEFSYM (Qcomma_at, ",@");
   DEFSYM (Qcomma_dot, ",.");
+  DEFSYM (Qshort_lambda, "short-lambda");
 
   DEFSYM (Qinhibit_file_name_operation, "inhibit-file-name-operation");
   DEFSYM (Qascii_character, "ascii-character");
-- 
1.8.4