On Mon, 27 Oct 2014 02:04:42 +0100, martijn brekelmans <tijntj...@msn.com> 
> Hello everybody,
> I'm fiddling around with clojure, and I'd like to use readable with clojure.

I've looked a little more at implementing "readable" (at least some tiers) in 
Clojure, beyond http://clojure.org/reader.

Without changing the core code you could implement basic curly infix with a 
somewhat different syntax and Clojure's tagged literals.  Tagged literals let 
you do "#my/tag element" - the reader then reads element, and passes through 
my/tag.  Reader tags without namespace qualifiers are reserved for Clojure, 
however, so the tag will be multiple characters. So the best you could do 
without changing the reader, as far as I can tell, would be something like 
#n/fx (i >= 0), where "#n/fx" is an infix processor for curly-infix.  That's 
ugly, especially if they are embedded: #n/fx (i >= #n/fx (a + b)).

Clojure has nothing user-accessible like the Common Lisp readtable.

Implementing any of the readable tiers with a nicer-looking syntax will require 
modifying the Clojure reader's source code. I took a quick peek at 
src/jvm/clojure/lang/LispReader.java - that appears to be where the key reader 
functionality is implemented.  It doesn't look like it'd be hard to add a 
variation of curly-infix or neoteric expressions, but getting those changes 
*accepted* might be another matter.

I'm sure backwards-compatibility is critical for them, so using #[...] instead 
of {...} is probably the only practical approach for them.

It might be sensible to start simple, just try to get #[...] accepted for as a 
notation for basic curly-infix (with NO neoteric support).  That has NO 
possibility of conflict with existing code.  We could warn users to NOT include 
syntax in there of the form a(b) with the assumption that it would be 
interpreted as "a (b)".  The next step would be to get neoteric supported 
inside #[...], at least in the sense of supporting a(....) as a synonym for (a 
...).  Maybe that version of neoteric could be supported at all times; the 
problem is not writing the code, it's getting such a change *accepted*.  It 
would be possible to also interpret "x[y...]" as "(x #[y...])", which would be 
full neoteric with a slightly different syntax.  Note that unprefixed [...] 
would continue to have its current meaning.

Any indentation-sensitive syntax would be a much bigger step - again, not 
because it's hard to implement, but because it has to be *accepted*.

Example of infix notation in this situation:
  #[#[a + b] > #[c * d]]
That is not as nice as {{a + b} > {c * d}}, but I don't see a nicer alternative 
unless they're willing to use non-ASCII pairing characters (!).

In Clojure [...] and (...) have a different meaning, but it seems to me that we 
should just leave [...] as-is.  Parens are way more common for enclosing larger 
scopes, as far as I can tell.

--- David A. Wheeler

Readable-discuss mailing list

Reply via email to