In Clojure [...] is lexically read as a vector (similar to Scheme
#(..)).  The Clojure eval then requires lambda arguments to be in a
vector rather than in a list.

>From what I notice, Clojure uses [ ] rather sparingly, so I think
indent should be ( )

On Wed, Oct 29, 2014 at 7:18 AM, David A. Wheeler <> wrote:
> On Mon, 27 Oct 2014 02:04:42 +0100, martijn brekelmans <> 
> wrote:
>> 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
> 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/ - 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

Readable-discuss mailing list

Reply via email to