I haven’t seen any. Also haven’t been on the lookout. Not particularly fond of that syntax. My brain refuses to help me restore the balance, and I get unpleasant surprises from refactor-rename at times. The latter depends a bit on how things in general are factored, so might not bite everyone.

I came up with this

(defmacro s->m
  [& syms]
  (if-not (and (seq syms)
             (every? symbol? syms))
    (println "All arguments must be symbols")
    `(do (into {} (map ~(fn [k v]
                          [(keyword k) v])
                       '~syms [~@syms])))))

(let [sym1 1
      sym2 2]
  (s->m sym1 sym2))
=> {:sym1 1, :sym2 2}

actually I think this slightly tweaked version works better

(defmacro syms->m
  [syms]
  `(do (into {} (map ~(fn [k v]
                        [(keyword k) v])
                     '~syms [~@syms]))))
=> #'user/syms->m
(let [{:keys [sym1 sym2]} {:sym1 42 :sym2 420}]
  (syms->m [sym1 sym2]))
=> {:sym1 42, :sym2 420}

Very cool! I think the latter approach will be necessary to support the mixing between lone symbols and key->value pairs that you have in JS. That gets less verbose with comma playing a role of separating the entries.

The :female_mage: :female_mage: have this one

I like this version

(defmacro locals [& xs]
  (zipmap (map keyword xs) xs))

(let [x 1 y 2]
  (locals x y))

@UK0810AQ2 gave it to me

Unsolicited opinion: I’ve worked in a code base that made heavy use of this kind of macro (can’t remember what it was called) and I felt that the savings (less typing?) was not worth the hassle. Mainly, grepping for keywords was more difficult, linters and dev tooling had more issues with understanding the code (this was before clj-kondo and macro expansions), it discouraged use of qualified keywords, and was just one more thing that was unfamiliar to clojure developers walking up to codebase.

If the need is primarily for tap debugging, one can also consider macros that just tap all local variables in a map (without needing the specify). I would consider also an editor macro that “converts” the shorthand to an actual map in the source code.

But maybe I just have some untreated PTSD from that project and I’m overreacting. Feel free to ignore ;)

I think the idea here is rather that if some language has a useful syntax, a lisp can most often be made to mimic it. Without attaching “should” there. 😀

I hear you @U05476190. A lot of this is just to demonstrate that Clojure can have something fairly similar but yeah, code generation always has some issues.

What I tend to do is one of these two: 1. Find a way to test it from the exported objects 2. Prefix the function name with _ Sometime 3: Refactor, because the need to test the function points at something being a bit weird. (However, I tend to not be this smart most often, so 1 and 2 are my gotos.)

prefix it with _internal_

in my experience, even _impl isn't clear enough that you should not rely on it as a public interface, this is why I've switched to the word "internal" in newer libs

Ah, makes sense. Just tell what it is.

Use defn-?

And use (#'myvar args) in the test

Oh wait. You're asking about typescript.

combobulate should give you some structural support for things

hmm. not sure what's going on with combobulate, but after following it's install instrux i end up with errors activating tree-sitter because it can't find a grammar .so ... even though i'm on macos and the grammars are in .dylibs

It's like more than half of the dragon book is about lexing and parsing! Who tf cares?! I don't want pretty syntax, I want no syntax

I have a theory that with the advent of LLMs for generating code, we will see a revival of lisp-like syntax. It took 20(?) years for people to move away from CISC cpu architectures back to RISC. I think something similar will happen with code generators over time: Google / Microsoft / Someone will introduce a brand new AI-focused language and will look like lisp/scheme. Not having too deal with syntax errors and working with simpler AST parsers and paredit-style modifications will make chatgpt-style prompts "smarter" and more likely to generate valid code. And all the languages will have transpilers from their respective syntaxes to this "ai-lisp-language", hence automatically increasing the overall training dataset (of logic/algorithms/etc) without actually having to scrape more code.

Of course, it won't actually be called "lisp". The marketing VPs would never allow that ;)

> Of course, it won’t actually be called “lisp”. The marketing VPs would never allow that 😉 The same way RDF, triplestores or the semantic web must not be mentioned when discussing Datomic. 😉

@U4P4NREBY have you moved all your config/data stuff into triple stores at this point? 😄 You seem very fond of them and their flexibility.

Yeah, I basically only use them now. 😅

That's very interesting. Do you tend to have a lot of custom transforming functions for creating more "easy" data structures to pull subsets of info from, or do you use some generalised transformation fn/library?

I am usually either pulling out a list of rows (like in a SQL result) or everything related to a specific resource/entity. In the latter case it’s simply a matter of collecting key-value pairs into a map, in the former you typically consume them as-is (just like with the results of a complex SQL query).