Unless you drop &, there's no reasonable way to distinguish between 1 2 and :b 2.

Hum... fair, though in my case both are mandatory, I guess if there was a way to tell Clojure about that it could be distinguished

Similarly, Clojure could know that :b is just my label, and so that will always be hard-coded at call-site, so it could also know from that

You could employ the JS technique to count the arguments. :D But I myself would rather just not use & at all.

So part of what's going on here is that when you use the & {:keys [a b]} syntax there's nothing special about the keys :a and :b from Clojure's perspective. It just wants to collect a map from arbitrary keys to arbitrary values, and there are no "required" keys to make a map. All that's happening is that the arguments are being poured into a map and then you're using a shorthand syntax to bind the symbols a and b to the matching keywords from the map.

And while potentially you could make the clojure compiler care about these, it would be a breaking change unless a brand new "type" of defn were introduced, which seems unlikely at this point.

Would it be breaking if it captured :a and :b ?

Well it would be breaking in this case if the compiler started to treat keys specified as required. Also I want you to keep in mind that you couldn't treat them as interchangeable in many cases, because Clojure focuses a lot on higher order functions, and you don't know if it will be called with named arguments or positional ones until it's actually called.

Ah ya, that one would. But I wasn't thinking it changed to always be required. You'd tag them as so explicitly. I think the other approach is better anyways. The compiler should just be aware of the keys, and if it sees them used in a call it can figure out where to dispatch. It does mean the compiler has to be fancier to track that, but I think that's non breaking and also would speed up dispatch since it can be determined at compile time.

Basically, if you see any call to that method that passed a static keyword as argument at the call site which is one of those keys, you'd know to call the positional one.

I mean you can provide this yourself with Clojure's :inline metadata.

Something like this, for example:

could pretty easily write a macro to generate this code.

Could even extend it to give default values to the different arguments in case a named argument is left off, etc.

The point is though that these sorts of changes are definitely a different interface from defn, and should be treated that way, because there's parts of this that just breaks existing usage. This doesn't just make legal some things that weren't legal before.

Interesting use of inline, I haven't used inlining yet for anything so I might need more time to parse it all. Frankly, I trust you that it possibly is breaking, I've only put limited thoughts into it. My current thoughts were that you could do something like:

(defn foo
  ([a b] (+ a b))
  ([& {:keys [a b]}] (foo a b)))

(foo 1 2)

(foo :a 1)

Yeah, I get what you intend, and you can have that behavior already with basically what I just did. You'd just need to write a macro that expands to it.

Have you seen https://github.com/jgrodziski/keycloak-clojure?

no I haven't. Thanks

No, that's how floating point arithmetic works.

Hum, I'd have to read up on the details around that again

https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html

Or a simpler explanation: https://www.exploringbinary.com/why-0-point-1-does-not-exist-in-floating-point/

Strictly speaking it's how BINARY represented floating-point arithmetic works

If only we had decimal computers????

I guess I'm confused though, if 100.34 isn't representable as a decimal of limited precision, why does it print it when I type 100.34 ?

Also why this works:

(+ 100 0.34)
;;=> 100.34

To add to the motivating confusion:

=> 0.1
0.1
=> (- 0.3 0.2)
0.09999999999999998

That last one is explained in the second link I shared. I.e. for displaying literal values that can't be represented properly as binary there is a fudge based on the bits available in the representation to display the value AS IF we could represent it. I suspect the same is true of the 0.34 example

It you want to carry out decimal calculations without losing precision AND you can cope with a fixed decimal point representation (i.e. a precision of n decimal places) you can use BigDecimal

The literal representation in Clojure is an M on the end of the literal value. E.g.

(- 300.34M 200)
=> 100.34M

P.S. I could have put an M on the end of both the 100.34 and the 200 but I was lazy... Clojure converted 200 (a long) into BigDecimal for me

user> (type (- 300.34 200))
java.lang.Double
user> (type (- 300.34M 200))
java.math.BigDecimal

user> (.scale (- 300.34M 200))
2

user> (.precision (- 300.34M 200))
5

I.e. this calculation has returned a BigDecimal with a scale (decimal places) of 2 and a precision of 5 (3 digits to left of decimal place and 2 after)

BTW this is the reason financial institutions often represent monetary values as integer values and assume the 2 decimal places for the pennies/cents or whatever the currency subdivision is for a decimal currency

Not looking forward to having to divide by 240 when the UK Tory government decides to bring back pre decimal currency! 😂 😉

@U0K064KQV Just round to two decimals and pocket the difference! With all those bits you will be rich in no time.

That was done in the late 60's by a COBOL programmer in a bank

Strictly speaking it was rounding the fractions of a penny from interest payments.

Interesting factoid! It’s also a major plot device of Office Space 🙂

And Superman 3

Also mentioned in one of a Science Fiction book series on a character calling himself the Stainless Steel Rat by Harry Harrison.

I have heard that most/all countries have either laws, and/or strict accounting rules, about such things.

You’ll get answers here and crossposting is frowned upon, but there's also #rewrite-clj

Solved thanks to @borkdude

https://github.com/matthiasn/talk-transcripts/blob/master/Hickey_Rich/EffectivePrograms.md probably

search for parochialism

@U07S8JGF7 yes, I think that's the one. Thanks!

you might want to post this over in #datomic and include some more info on version etc

I can’t seem to find #datomic, that’s why i posted it here

@U9BQ06G6T if you click on the highlighted #datomic link in the above message it should take you directly there.

just did that 😄

ocaml has a somewhat similar syntax/operator with |> if you squint a little. But it is not really a lisp

To be clear OCaml |> is equivalent to Clojure ->>

Ok cool I'll take a look at that. I've never messed around with OCaml

It reminds me a lot of various constructs in R, particularly in the dplyr package.

That makes sense! Ty

Speaking of docstrings - the lack of a convention/standard/consensus on a (opt-in obviously) docstring format intrigues/confuses me. At least in my codebase, I find docstrings and specs so frustratingly rare. Even when docstrings are written, they're often in an unstructured, incomplete or overly prose manner. I often have to read the function body (or some entire chain thereof sometimes 😿). Obviously a conventional format(s) won't stop incomplete docstrings, but they at least open the door for IDEs to offer conveniences like autocomplete block comments with parameters/return prepared, convenient hover and spelling/autocomplete help for individual parameters. Further, the mere ubiquity or presence of such structured docstrings I'd argue can coax people into adding a couple of words or a line or two about parameters or returns, when they'd previously just write a couple words about the function overall. Im thinking about javadoc and jsdoc for inspo. I might also be totally wrong and just didn't do my research about clj equivalent endeavors, but I haven't seen anything to this effect so far 😕

Wha..?? This is amazing!! I gotta see how you did this 😄

I have a talk about this: https://www.youtube.com/watch?v=Ygrml6tyrq0 It was actually my first Clojure talk ever, I believe

well, on a conference

it's only 15 minutes

Just watched, that was great. Such a creative project. Self-hosted CLJS is soo cool. I really want to go to Clojure conference IRL sometime soon hopefully.

No, but you can use cond-> to shorten it a bit.

👍

And 1.11 now has parse-long

(cond-> open_time
  string? parse-long)

@U3JH98J4R almost (cond-> open_time (string? open_time) parse-long)

Another instance of the cond that threads in the condition as well. Sean Corfield I believe has a open source lib with such cond.

we have a macro in the codebase that does that^ my brain just short circuited

A fif-function is a cute addition to any codebase!

(defn fif [pred fun]
  #(if (pred %)
     (fun %)
     %))
(def long-if-string (fif string? parse-long))
(long-if-string "1") ; => 1
(long-if-string :1) ; => :1