btw, I yapped so much we never got to: https://kennytilton.github.io/web-mx-quickstart/#/ That is as terse as I can get!

I will have to take a look but we probably could have a custom constructor that would hoplonify lit elements.

Is https://lit.dev the one you are talking about?

> Is https://lit.dev the one you are talking about? Yes. Thanks.

I saw a wiki page about using hoplon with polymer when I was checking for stale information about Hoplon and in that case I think there was nothing Hoplon specific happening: https://github.com/hoplon/hoplon/wiki/Hoplon-with-Polymer :thinking_face:

You can treat hiccup as data and do things like

(-> [:div]
    (conj [:span "Hello"]))

People also like that you can check the structure without rendering in a browser, you can test that the data returned has some shape or is equal to some vector.

Okay, but what about:

user=> `(println (str "Hello" ~(+ 41 1)))
(clojure.core/println (clojure.core/str "Hello" 42))

Then:

user=> (def tpl `(println (str "Hello" ~(+ 41 1))))
#'user/tpl
user=> tpl
(clojure.core/println (clojure.core/str "Hello" 42))
user=> (= '(clojure.core/println (clojure.core/str "Hello" 42)) tpl)
true

You cannot see what clojure.core/str would produce.

In my hypothetical, I'm imagining that println is like <p... and str... is like <span... in Hoplon.

(def elem1 [:span "Hello"])
(def elem2 [:div :.class])
(= [:div :.class [:span "Hello"]] (conj elem2 elem1))

But '(clojure.core/conj elem2 elem1) would not be the same.

At the end of the day, I'm hearing that the difference is that Hiccup uses vectors and vectors conj onto the tail instead of the head, which is more convenient?

e.g.:

(-> `(str "Hello,") (concat ["world"]))

Well, conj is an example but call a function would have the same effect, if you are using hiccup you would get the final vector and could transform it into something else. Let me try a more clear example:

(defn custom-element
  [greet]
  [:span :.greet greet])
(= [:span :.greet "Hello"] (custom-element "Hello"))

(defn custom-element-hoplon
  [greet]
  (h/span :class "greet" greet))
(= '(myns/custom-element-hoplon "Hello") `(custom-element-hoplon "Hello"))

Right. In Hoplon, it's conventional to build custom elements via fns versus always working at the meta level, then running the Hiccup interpreter to get the DOM. That said, I think there's nothing stopping us from using quote, syntax-quote, syntax-unquote, and friends to return lists instead of vectors. Then we eval the result. If we're scared of naked eval, we could write an (hl-eval function that sanity checks everything in function-call position... Same level of abstraction; plus we get automatic editor support. Since UI trees aren't that large, I'm thinking that the fact that appending to lists is O(n) probably doesn't matter in real life? Thoughts? My instinct is that I can't be the first person to have thought of this and so I strongly feel I might have missed something here...?

I have asked the same. I do not hear much about the ability to program UIs by juggling vectors with CLJ, but I have heard folks say they liked the syntactic bifurcation of code from HTML. Me, I love the syntactic unification of code and DOM we see in Hoplon. Hiccup to me is being forced to change gears, if you will, mid-coding. And as you suggested, @U1U91M1B5, to what end? I have to think another factor is the React and JSX ancestry of CLJS libraries. Hiccup was just a natural translation of JSX into CLJ. And creatures of habit are we. And don't forget Tilton's Law: Never ask me, Why? I am just going to invent an incredibly plausible reason unrelated to why.

Makes sense @U0PUGPSFR. I'm glad I'm not the only person asking--and for similar reasons. We probably both learned Lisp without syntactic sugar for vectors... 😄 To me, something like this feels natural:

user=> (defn p
       "Paragraph tag stub"
       [& more]
       (apply str "<p>" (apply str (doall (interpose " " more))) "</p>"))
#'user/p
user=> (p "hello" "world")
"<p>hello world</p>"
user=> (defn greet [you]
         `(p "hello" ~you))
#'user/greet
user=> (greet "me")
(user/p "hello" "me")
user=> (eval (greet "me"))
"<p>hello me</p>"
user=>

this is pure philosophizing and retrospective analysis which is usually fraught/absurdly off base

but my vague impression at the time we made hoplon was that hiccup felt like a greenspun's 10th rule situation

things that started with it tended to sprout novel evaluation semantics and naming schemes that were parts of lisp, re-imagined somehow around (usually) specially named keywords

in retrospect and in my own experience, having learned CL in the meantime, i see an insurmountable level and phase distinction between the idea of hiccup and actual HTML. namely, a callback on an actual element is passed this and otherwise has direct control of an embodied resource, at runtime

if you go the hiccup route, you have to reimplement everything about runtime events yousrelf for hiccup-time. this doesn't seem like much until you realize it includes event bubbling

hiccup escapes event re-implementation for the clojurist, but it's still there in the React runtime

also, i think when it was made available, the fluidity of manipulating pure data in cljs vs. everything else was pretty astounding to most peolpe

i guess another mark of the mismatch is the ^key business, they need to impose identity semantics

oh, it's also worth noting i suppose, that hiccup had lots of traction before cljs appeared. it was/is the premier way to produce markup from clj

https://github.com/cgrand/enlive was another popular way that is interesting

> Thanks @U04VC31U8.

Speaking of Lisp, with DOM as CLJ functions, well, we also have DOM as macros, and with macros we have all sorts of options for making code expressive/minimalist, and for producing proxy DOM that can be easily navigated for state sharing.