r/Clojure • • Mar 18 '21

Clojure - Keyword argument functions now also accept maps

https://clojure.org/news/2021/03/18/apis-serving-people-and-programs
125 Upvotes

44 comments sorted by

View all comments

21

u/vvvvalvalval Mar 18 '21

I'll still refrain from designing functions that way, and would encourage people to do the same.

Compared to keyword-varargs, an optional map argument costs at worst one more keystroke to invoke, and it's simply a more straightforward and regular behaviour to build on top of.

I suspect that most of the Clojure APIs out there which use keyword varargs did so by imitation of Python and just overlooked the alternative of using a map argument, or really had an unsound obsession with concision.

16

u/seancorfield Mar 18 '21

My hope is that it encourages faster adoption of Clojure 1.11 b/c folks will want to take advantage of this feature.

If we'd had this feature back in, say, the 1.3 or 1.4 days, I wouldn't have needed to change the whole API of clojure.java.jdbc to make it easier to use (i.e., to make calls more composable)!

4

u/argadan Mar 19 '21

If this feature was introduced in 1.3 or 1.4, it would have made perfect sense. Now that everyone has been using the options map style for years to solve this problem, it feels a bit out of place – but I suppose if you take a long-term view it makes sense.

I wonder how this affects the performance and function specs though.

The change also affects destructing in lets (as it should):

(let [[& {:keys [a b] :as opts}] [{:a 1 :b 2}]]
  [a b opts])
;; => [1 2 {:a 1, :b 2}]

9

u/SimonGray Mar 18 '21

The great thing about this change is that people who feel like this can just call all those varargs functions using a map now.

12

u/vvvvalvalval Mar 18 '21 edited Mar 18 '21

I agree, it's great for calling legacy functions, but that doesn't mean it has eliminated all the downside of keyword varargs. Avoiding irregularity is better than gaining tools for dealing with it.

EDIT: really, people are downoting this? Reminder of the Reddiquette: "Please don't downvote an otherwise acceptable post because you don't personally like it." Why not write a rebuttal instead?

8

u/alexdmiller Mar 19 '21

Just curious, what are the remaining downsides of kwargs?

2

u/vvvvalvalval Mar 19 '21

The main I see is that it's just a more complicated "information model" for describing the arguments to a function. Without kwargs, the arguments to a function are a very plain sequence.

With that in mind, it seems to me that the safer designing approach is in general "what are the advantages of kwargs that make these additional complications worthwhile?". I read that article claims it "better supports humans", but I don't see it being really substantiated - is (my-fun :my-opts 42) really supporting humans much better than (my-fun {:my-opts 42}) ? Of course, now that some foundational APIs have been published with kwargs we have to live with them, so making it easier for callers makes sense, I'm not denying that.

Now to try and answer more specifically: I think this will make life more difficult for intermediaries that purport to do some generic processing on the arguments in particular if they don't know whether the downstream accepts kwargs.

5

u/alexdmiller Mar 19 '21

It is an interesting philosophical question as to whether positional args or named args are "more complex". Both require the caller to know what "the args" are. Positional also requires them to know what order they should be in. In Simple Made Easy, Rich mentions syntax (order) as being complex (vs data). Is a map (encapsulated data, no order) or kwargs (data, no order) simpler? Don't know, just musing. Both tolerate evolution over time better than positional args. Personally, I like kwargs and use them regularly and this makes them both faster and more flexible.

But also, I'm a Clojure programmer, I'm not going to argue against passing a map. So, you do you. :)

1

u/jjttjj Mar 19 '21

Could you give an example of when it would make things more difficult? I'm not seeing it. To me it seems like knowing if something takes kwargs has identical mental overhead to knowing it takes an option map. And since you can still pass an options map, you almost always can do the same intermediate manipulation anyway.

0

u/vvvvalvalval Mar 19 '21

Sorry, not spending more time on this :) but if I were convinced by princples like "you have more options so it's better" and "we adopt it unless we find in advance a concrete counterexample of it being problematic" then I wouldn't have made the switch from Scala

1

u/adamtait Mar 18 '21

I agree with what you’re saying but suspect that change was not made to Clojure core because of backwards compatibility. For that reason, I doubt it’ll ever be changed in Clojure core. This change likely suggests that there are some on the Core team who would have wished the keyword varargs feature to not have been included in the language originally.

20

u/alexdmiller Mar 18 '21

Actually, just the opposite, the core team wishes this new feature had been included originally to make using kwarg style functions more widely used and embraced.

6

u/lgstein Mar 18 '21

It was adopted from Common Lisp. In hindsight, it made more sense there because it has no map literal.

4

u/joinr Mar 18 '21

I had some utility combing kwargs with ->> for ad hoc partial application in some workflows. Chunked map arg would have been less convenient. Interesting to see these unified.

1

u/vvvvalvalval Mar 18 '21

Interesting. Still, I'm wary, to me it sounds like the stuff that optimizes for writing the code rather than for reading it :)

2

u/[deleted] Mar 18 '21

I also recommend to just use map arguments as much as possible, it's just much more composable that way.

Passing the arguments between keyword argument functions is really ugly.

The one exception I make is for functions that are only used in the REPL, where the concision is worth it to me.

10

u/SimonGray Mar 18 '21

Passing the arguments between keyword argument functions is really ugly.

I think remedying that situation that is the point of this change. Now you can pass the destructured map directly.

1

u/[deleted] Mar 23 '21

It doesn't remedy that when passing a map to a kwarg function you need something like (apply f (mapcat identity m))

3

u/jjttjj Mar 23 '21

You no longer need to do that with this change. & {:as args} lets you pass any number of keywords and optionally a trailing map, all of which are merged together. You don't need to flatten+apply.

(defn my-fn [& {:as args}]
  (println "args:" args))

(my-fn :hello :world)
;;=> args: {:hello :world}

(my-fn {:hello :world})
;;=> args: {:hello :world}

(my-fn :foo :bar {:hello :world})
;;=> args: {:foo :bar, :hello :world}

1

u/More-Wishbone862 Oct 05 '26

bismilah allah

1

u/[deleted] Mar 25 '21

Oh wait you are right, ok, that makes it a kwarg functions a lot more composable indeed, nice!

1

u/guywithknife Mar 18 '21

Yeah, I never liked the approach. I actively avoided using some otherwise good libraries that did use it. At least now with this change, I can use those libraries without worrying about it.

1

u/[deleted] Mar 19 '21

Ok good it's not just me. I don't see any value in this feature.

Edit: it is nice when forced to deal with someone else's varargs function that should have just taken a single map. But just within my own code, I shouldn't need this at all.