Clojurians Log v2

The example from the SPEC for prompt is parsed as follows:

[':prompt', {'edn/map': [[':file', 'unrepl-session'], [':line', 1], [':column', 1 ], [':offset', 0], [{'edn/symbol': 'clojure.core/warn-on-reflection'}, v:null], [{'edn/symbol': 'clojure.core/ns'}, {'edn/tag': 'unrepl/ns', 'edn/value': {'edn/ symbol': 'user'}}]]}]

The interesting part is the very last 'user'.

So this is the code I need to get there:

for [ k, v ] in a:response[1]["edn/map"] if type(k) == v:t_dict \ && has_key(k, "edn/symbol") \ && k["edn/symbol"] == "clojure.core/ns" let a:this.namespace = v["edn/value"]["edn/symbol"] break endif endfor

Where I'd like to do: let a:this.namespace = a:response[1]["clojure.core/ns"]

I'll write a simplifier to apply in such cases, which translates for example list or symbols to vim lists and strings. The means, I cannot distinguish lists and vectors anymore. As well as symbols and strings.

But in this side, I don't have to anyway.

Elisions can be special cased to be left alone. But I don't need their contents, since they act as a template only.

Why not use a serialized representation for keys?

Aka don’t parse strings or symbols or keywords.

Serialized represantation?

From what I get keywords are represented as “:kw” then keep on with this trend: “sym” and "\”str\”” etc

Hrm. That would be a possibility.

But maybe the :kw is already a bad idea and should be an edn/keyword map.

Actually I think latent parsing (no it’s not a thing I just made the term up) is a good idea.

latent parsing?

Parsing where some nodes in the resulting tree are just spans of the actual input.

Hmm... I'm not completely convinced. It may work with keywords, symbols and strings, because you can use the first character to discriminate the type.

But it breaks down with tagged values.

There you can still use # for the dispatch in the string, but you cannot access to payload easily.

Then you need again to fire up the parser.

Are there tagged values used as keys?

Dunno hopefully not. This maybe a question, how general purpose the parser should be. Also keeping strings as double quoted puts the escape burden on the user. Not nice.

Fluffing around with strings.... Don't want that. This should be handled by the system.

Treat strings as opaque and provide fns to check the actual type etc

General purpose parser is somehow a sub project of its own. Parsley Clojure parser has been detrimental to CCW imo. However it has somehow succeeded on its own (because of an empty ecosystem niche)

It's also the other way: I can't just stick a string in. And that's almost always what I want to do. But then it would be considered a symbol. So I must wrap it in ". But now I also have to take care that things are escaped correctly. Bleh. :-(

But that might be an encoding issue. Maybe a prefix is better: :: keyword, ': symbol, s: string. And hope that there are no tagged literal as key. (#inst anyone?)

In the end it boils down to intended usage: Do I want a full blown parser/generator for EDN? Or is the need for vimpire more important/sufficient. Actually I need both. The first for the actions which have to be traversed for parameter replacement (so no opaque tagged literals!) and have to produce exact EDN. Then the latter for the tooling interaction, where ease of accessibility is key. But there I don't need sets or symbols. There I can live a simplified translation.

yeah you could also introduce you own serialization to encode as strings all kind of keys. However if you really want to be generic then: what when you get maps as keys? You would need to write a canonicalization algorithm for maps to be independent of the key order...

I disagree that you need a full blown parser to perform substitutions. It can be done at the string level (extra points for taking care to figure out that you are not in an escaped context (eg string))

String level? With escaped context? And who got that ever right?

framed like that it feels preposterous to say “me” but.. in the blob generation code, the regex-from-hell-that-blows-stupid-Java-regex-matching or the hand crafted state-machine that replaces it.

This state machine knows if you are in normal code or in some escaped context.