missing collection opt value is parsed to contain true

[trptr]

(cli/parse-opts [":opt"] {:coerce {:opt [:string]}})

current:

{:opt ["true"]}

expected:

{:opt []}

Notes

1.
The given example should not result {:opt [""]}.

If [""] is wanted, then it is possible via:

(cli/parse-opts [":opt" ""] {:coerce {:opt [:string]}})
{:opt [""]}

2.

(cli/parse-opts [":opt"] {:coerce {:opt [:boolean]}})

current:

{:opt [true]}

expected:

{:opt []} ;; inconsistent to the non-collection version, where missing value defaults to true?

or

{:opt [true]} ;; inconsistent to the proposal for other collections, where missing value results empty collection

I don't have a strong opinion here, but I would vote for {:opt []}, keeping "empty means true" an exception exclusively limited to (non collection) booleans.

3.
The other common collections (#{}, ()) should work similarly & data type (:string, :keyword, :symbol, :int, ...) should not matter:

(cli/parse-opts [":opt"] {:coerce {:opt (list :keyword)}})
{:opt ()}

(cli/parse-opts [":opt"] {:coerce {:opt #{:int}}}) ;; currently throws
{:opt #{}}

4.

(cli/parse-opts [":opt" "a" ":opt"] {:coerce {:opt [:string]}})
{:opt ["a"]} ;; so we can't distinguish  [":opt" "a" ":opt"] and  [":opt" "a"]...

;; alternatively we could throw in this case,
;; because no acceptable value is given for one :opt (the last one in this example) 

5.
The proposed functionality can be achieved by changing add-val to the following. (This is, I guess, not the most performant alternative...)

(defn- add-val [acc current-opt collect-fn coerce-fn arg implicit-true?]
  (let [arg (delay (if (and coerce-fn
                            (not (coll? coerce-fn))) (coerce* arg coerce-fn implicit-true?)
                       (auto-coerce arg)))]
    (if collect-fn
      (if implicit-true?
        (update acc current-opt collect-fn)
        (update acc current-opt collect-fn @arg))
      (assoc acc current-opt @arg))))

[borkdude]

The fix for #58 was the same as the fix for #57 since --opt without an additional value is always interpreted as "implicit true", i.e. a boolean flag.