what’s more clojurian? default args with & {:keys …} or [….] OR multiple arities

I think they are both ok

the former has been found to be kind of annoying if you need to call into another layer down with the same style

generally I tend towards passing an explicit map

except if you have an outer-most api layer that humans will likely type at a repl, where I will use the kwargs style

b/c it's good for people

multiple arities can also be good for people (but is more brittle)

You can always do both:

(defn func
  ([opts] (... opts ...)) ; opts is a hash map
  ([k v & kvs] (func (apply hash-map k v kvs))))

(off the top of my head, not even typed into a REPL so excuse any errors etc)

the worst of all worlds :)

Hahaha... or the best

It's certainly not something I'd do as a matter of course. It's useful as a way to migrate from one approach to the other when you realize the {:keys [...]} approach doesn't "scale"

Want to pass a def two names.

Like (def default-user free-plan <string>)

Is this doable?

Bind a string to two names?

@urbanslug: def as a special form takes only one symbol and has no multiple arities

@urbanslug: if you try, you'll get a RuntimeException: to many arguments

Yeah, that’s what the books say. Was hoping there was a workaround.

user=> (def test-user free-plan "user") CompilerException java.lang.RuntimeException: Too many arguments to def, compiling: [...]

@urbanslug: (def test-user (def free-plan "string"))

oh yeah ^5

@urbanslug: works, but test-user points to the free-plan, not it's value

@urbanslug: user=> free-plan "string" user=> test-user #'user/free-plan

Cool that’s what I want.

To reuse the specific string.

@urbanslug: user=> (var-get test-user) "string"

@urbanslug: this will help you get the specific value, when you need it

@urbanslug would pretty easy to make a macro called defmulti or somesuch

defmulti already exists in clojure and it's used to define multimethods

sure, poor naming by me

deflots

defdef

I'm sure there's a way better way to write this, but:

product=> (defmacro defdef [val & names] (let [named (map (fn [n] `(def ~n ~val)) names)] `(do ~@named)))
#'product/defdef
product=> (macroexpand '(defdef "hello" foo bar))
(do (def foo "hello") (def bar "hello"))
product=> (defdef "hello!" foo bar)
#'product/bar
product=> foo
"hello!"
product=> bar
"hello!"

Why would you want to do that? (I guess I missed your justification)

No idea - somebody was just asking how to do it

yeah, not sure that is a good idea.