Okay. So there's one big thing you're doing wrong here just from reading 
your grammars: you are complecting the datastructures and valid _tokens_ 
which make up the clojure language with the _meaing_ associated therewith 
by the language. If you discard such things as destructuring as "part of 
the grammar" and instead just provide the parse grammars for basic 
datastructures like symbols, maps, keywords sets and soforth it's trivial 
to produce a grammar which can _parse_ valid clojure code. _Reading_ 
clojure code from such a parse tree is and should be an entirely seperate 
concern, implemented as a pass over the generated parse structure.

- Reid

On Thursday, February 6, 2014 9:28:08 PM UTC-6, Travis Moy wrote:
>
> I'm trying to use instaparse to parse Clojure code so that I can reformat 
> it, but I'm having an issue with how to handle special forms. Should I 
> attempt to parse special forms such as let and defn into their own rules, 
> or should I rely instead on the actual content of the terminal to determine 
> what lists should be treated as special forms?
>
> For example, let's say I want to write a function which takes the parse 
> tree returned by instaparse and arranges all the let bindings as 
> recommended by the Clojure style guide (
> https://github.com/bbatsov/clojure-style-guide#source-code-layout--organization).
>  
> There are two approaches I could take:
>
> 1) Build the recognition into the grammar itself:
>
> S = Form*
>>
>> <Form> = !SpecialForm List | ReaderMacro | Literal | Vector | Map | 
>>          SpecialForm | !SpecialForm Symbol
>>     
>>     List = '(' Form* ')'
>>
>>    ...
>>
>>     <SpecialForm> = defn | let | try | JavaMemberAccess | JavaConstructor
>>         defn = '(' "defn" Symbol String? MapMetadata? VectorDestructuring 
>> Form* ')'
>>
>> <Destructuring> = VectorDestructuring | MapDestructuring
>>     VectorDestructuring = '[' (Symbol | Destructuring)* ('&' (Symbol | 
>> Destructuring))? ']'
>>     MapDestructuring = Map
>>
>
> 2) Don't try to detect the let bindings in the grammar. Instead, search 
> the resulting parse tree for lists with "let" content.
>
> Which of these is a better approach? I sadly didn't take compilers in 
> college so I'm kind of playing this by ear; I'm sure if I had I'd have a 
> better idea of what the best practice is here.
>
> Thanks!
>
> (Full code for my project is at 
> https://github.com/MoyTW/clojure-toys/tree/master/formatter if needed)
>
>

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.

Reply via email to