Perhaps they've grouped it all into "Lisp". Even though a dedicated page there says that "Lisp", "Common Lisp", "Elisp", "Clojure" are all separate languages that are not grouped together, only "Lisp" is mentioned by the index itself.

On the other hand, Scheme is there, as well as Racket...

I don't take it too personally... as you said, other lisps are there. I don't think it's too much of a reach for interest in LISP to take you in the direction of Clojure in 2022

I had an executive politically attack my use of Clojure based on its non-presence in this list just the other day. It would be nice if this were rectified, especially considering how distinct Clojure is from "common lisp".

https://redmonk.com/sogrady/2022/03/28/language-rankings-1-22/ Check out the graph. Clojure is not doing that badly, all things considered. Falls firmly at the head of the pack of "future-leaning" languages with the exception of Haskell alone

According to RedMonk WebAssembly is dead 😛 Ymmv

@U0KLE4WHZ I know clojure is alright, I am not alarmed 🙂 Just hinting that one particular public ranking does not exhibit that. But yeah, it actually looks pretty good on redmonk.

According to the TIOBE website, all they do is search for the number of hits when doing a search for +<language> programming So in theory, we should encourage everyone who writes articles about Clojure to include Clojure programming in their content and metadata (assuming TIOBE bothered to include Clojure as one of their searches) I rarely use the term programming in any of my content, so wouldnt be surprised if its not included. They also use a limited set of search engines. TIOBE seems a pretty limited approach to understanding popularity, but then popularity is such a vague and unimportant aspect to making software engineering decisions. If executives are discounting a language I was using, then I would ask them which language I should use and if they are willing to stake their own reputation upon my delivery of (or politely suggest they leave the technical decisions to those who are hired to make them)

@U05254DQM I just saw the HOPL IV talk the other day where Rich Hickey suggested people who want traction with their new languages create something that's easily searchable because it's a unique word... poor guy wasn't thinking about TIOBE when everyone out there is just searching for Clojure 😛

Also, btw, sorry to beat this dead thread, but Clojure is most definitely on TIOBE's July list. It's in its usual place of somewhere between 51-100. So don't worry, it's not dead yet 😛

No, but you can put an atom in a record if you need state

how i can mutate field of deftype? or i misread documentation?

found, nvm https://gist.github.com/shinmuro/9338262 thanks

then you also need to know when there is a qualified symbol to interpolate and when continuation of the string. foo ~

~(do http://i.am/x)

This just works fine though:

(prn (<< "hello ~clojure.core/inc"))

not sure what the problem is exactly?

(prn (let [name "apple"] (<< "These are ~(do name)s")))
"These are apples"

then clj-kondo would complain about redundant do 🙂 My comment was about ~x in your example

Yeah, I get that ~{name}s might read a little bit nicer, but not sure if there's much difference

(prn (let [name "apple"] (<< "These are ~(-> name)s")))

clj-kondo does not complain about redundant do's from hook macro-expansions

at least the difference is three chars in do

fair enough. and inlining maps seems uncommon enough to re-use these chars for that

Other languages have:

${...}

${ (+ 1 2 3) }

~{ {:x 1} } still should be possible, but I agree that inlining maps is uncommon

yes, so just having ${ ... } seems enough and seems to align with at least JS:

> `Hello $x`
"Hello $x"
> `Hello ${x}`
"Hello 123"

Tracking some thoughts here: https://github.com/babashka/nbb/issues/231

It's awesome that we can do this in a Clojure macro though and not depend on some language committee :)

totally!)

What if ~ simply let's the clojure reader read until it's done?

interesting, but could it work with reader conditionals? doesn’t look like so

@U3X7174KS That's what I got now in the linked issue, but as delaguardo said, this doesn't play nice with: (let [name "apple"] (<< "I've got 10 ~names"))

Oh, right 👍 (I skimmed a bit)

so, tl;dr: I think just supporting ${ ... } is enough for both single and composite values, and the notation aligns with other languages.

Reading this now: https://openjdk.org/jeps/8273943 It seems the ~x shorthand is also supported in some other languages Well, maybe Chas just had it right and I should take it over verbatim :)

Eh no, now I was confused. Chas had ~{ ... } and ~( ....) while I think you could just have ${ x } and ${ (+ 1 2 3) } while supporting ~x could be a nice-to-have

Everytime I've asked about string interpolation and HEREDOC style strings it seems the core team is against that

Though I think since Java is getting them soon, maybe that will be a good time for Clojure as well

One more problem with Chas's implementation is That

(<< "val a: ~{nil}") ;=> "val a: "

main() {
  final b = null;
  print("val a: $b"); // val a: null
}

Maybe then pr-str?

It depends which semantics you would like to have. I would like to embed a string literal within a string I think?

(let [x "dude"] (<< "val: ~{x}"))

in that sense, maybe it's also fine to have nothing for nil, not sure

Or there could be pr-<< macro with pr-str behavior

As to your first question, the documentation is probably incorrect. And regarding sending the data somewhere - depends on what exactly you're using for email sending or S3 uploading.

I am using the aws sdk, both for s3 and ses (for email)

Use https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/services/s3/S3Client.html#putObject-java.util.function.Consumer-software.amazon.awssdk.core.sync.RequestBody- in combination with https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/core/sync/RequestBody.html#fromInputStream-java.io.InputStream-long-.

great, thanks!

user=> (with-precision 2 :rounding CEILING (/ (- price average-price) average-price))
0.0084M
user=> (with-precision 2 :rounding FLOOR (/ (- price average-price) average-price))
-0.032M
user=> (with-precision 2 :rounding HALF_DOWN (/ (- price average-price) average-price))
0.0083M
user=> (with-precision 2 :rounding DOWN (/ (- price average-price) average-price))
0.0083M
user=> (with-precision 2 :rounding UP (/ (- price average-price) average-price))
-0.032M
user=>

See the docstring:

user=> (doc with-precision)
-------------------------
clojure.core/with-precision
([precision & exprs])
Macro
  Sets the precision and rounding mode to be used for BigDecimal operations.

  Usage: (with-precision 10 (/ 1M 3))
  or:    (with-precision 10 :rounding HALF_DOWN (/ 1M 3))

  The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,
  HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.

See my threaded response to your first post but also:

user=> (with-precision 2 (- price average-price))
0.21M
user=> (with-precision 2 :rounding UP (- price average-price))
-0.79M
user=> (with-precision 2 :rounding DOWN (- price average-price))
0.21M
user=>