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 <dwhee...@dwheeler.com> wrote: > On Mon, 27 Oct 2014 02:04:42 +0100, martijn brekelmans <tijntj...@msn.com> > 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 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 > Readable-discuss@lists.sourceforge.net > https://lists.sourceforge.net/lists/listinfo/readable-discuss ------------------------------------------------------------------------------ _______________________________________________ Readable-discuss mailing list Readable-discuss@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/readable-discuss
