带谓词的Clojure默认值

Question

A common pattern is to provide a default value if some value does not fulfill a predicate. What is a good way of writing such a pattern when the value is not bound to a name?

Currently I use a let expression. If for example I would like to provide a default value for empty strings I might write something like:

(let [value {:a "foo"}]
  (if (:a value) value {:a "bar"})) 

However, I feel like this could be simplified to closer match the same proceduce for falsy values.

(or value default)

I have considered creating a function that does it:

(defn or-default [pred value default]
  (if (pred value) value default))

With which the above example would become:

(or-default :a {:a "foo"} {:a "bar"})

However I assume someone must have thought about this earlier, so is there an established way?

Answer 1

You can use destructuring to solve this

(let [{:keys [a] :or {a "default"}} {:b "foo"}] a)
;; => default

Also, get lets you provide a default value:

(get :a {:b "foo"} "default")
;; => default

Also works with keyword access

 (:a {:b "foo"} "default")
 ;;=> default

Answer 2

For supplying default values for map keys, the function you are looking for is essentially merge with the defaults as the first argument:

(merge {:a :a-default} {})
=> {:a :a-default}
(merge {:a :a-default} {:b 1})
=> {:a :a-default, :b 1}
(merge {:b 1, :a 2} {:a :a-default} {:b 1, :a 2})
=> {:b 1, :a 2}

We can package this as function map-defaults that, given the defaults, returns a function that fills them in:

(defn map-defaults [defaults]
  (partial merge defaults))

We can use this to create functions that perform particular defaults:

(def person-default 
  (map-defaults
    {:income 0
     :married false
     :forenames []}))

(person-default {})
=> {:income 0, :married false, :forenames []}

(person-default {:married true, :income 88000})
=> {:income 88000, :married true, :forenames []}

It is in the nature of defaults that they are used repeatedly, and the above is an easy way to do this.