String interpolation

[borkdude]

@corasaurus-hex String interpolation is a different issue: this issue is just about generating more efficient code for (str foo bar) => cherry/str(foo,bar) vs foo + bar.
I think string interpolation should also be a built-in feature that compiles directly to JS string interpolation. We can support this using a reader template #i "foo ${name}". I'll make a different issue for that.

Originally posted by @borkdude in #10 (comment)

[lilactown]

Nitpicking: #i is a bit ambiguous, what about #str?

[borkdude]

Yes, #i isn't a good choice. Not sure about #str, maybe too general?. What about #<<? << was the string interpolation macro in clojure.contrib. Too cryptic?

#<< "hello ${name}"

[borkdude]

Or #$ "hello ${name}: too Perly...

[lilactown]

Outside of the reader tag we use, how ought we to handle custom tag functions? Something that would expand to

html`<div style="color: red;">hello ${user}!</div>`

[lilactown]

perhaps we could allow passing in a list, like #tmpl (html "<div style=\"color: red;\">hello ${user}!</div>")

[corasaurus-hex]

maybe #` ? Some way to indicate that these are backticks?

[corasaurus-hex]

oh dang that's not bad @lilactown, I like it

[corasaurus-hex]

how does that generalize to bare template strings, though?

[lilactown]

i'm a bit ignorant of how the reader works is but i think we could have it support both bare strings as well as lists with a tag function

#tmpl "Hello, ${user}!"

#tmpl (html "<div style=\"color: red;\">hello ${user}!</div>")

I'm using tmpl as a stand in for whatever we decide to use.

[lilactown]

Thinking out loud, I'm worried about how we'll handle complex cases than just interpolating a variable. For instance, how should we handle expressions?

#tmpl "Hello, ${(:name user)}!"

Perhaps we should lean into the tag accepting a collection, and instead of writing the ${} syntax directly we write lists

#tmpl ("Hello, " user-name "!")
#tmpl ("Hello, " (:name user) "!")
#tmpl (html "<div style=\"color: red;\">Hello, " user-name "!</div>")

[borkdude]

#tmpl ("Hello, " user-name "!")

Hmm, this isn't any better to me than just using str. The point of "${foo}" is that it's easier to write.

We could support #tmpl "Hello ${name}" and #tmpl [:html "<pre>${name}</pre>].

[lilactown]

@borkdude how should we handle arbitrary expressions inside of the template string, like I was talking about above?

[lilactown]

To be up front, I see the differences between this and str to be very small - I prefer using str over format and similar most of the time - and am mostly motivated by the ability to easily use tagged literals like lit-html's html tag

[borkdude]

@lilactown I'm very sensitive to the argument that static analysis should not be made harder :-) I like your idea of providing a map with arguments, this is quite similar to how Selmer works.

[borkdude]

(ns subst
  (:require [clojure.string :as str]))

(defn subst [s m]
  (reduce-kv
   (fn [acc k v]
     (str/replace acc (str "$" (name k)) (str v)))
   s m))

(prn (subst "$num + $num = $sum"
            {:num 1
             :sum (+ 1 1)}))
;; "1 + 1 = 2"

I think it doesn't even have to be a reader macro, could just be a function or maybe a macro to optimize constants and then defer to a runtime construct.

[lilactown]

I think we'd want it at least to be a special form so that it can output backtics

[borkdude]

Oh wait, yeah, we were constructing a compiled form from this, I forgot.