如果任何给定的值不是空集合，如何在Clojure中测试？

Question

I need a predicate which returns logically true if the given value is a not-empty collection and logically false if it's anything else (number, string etc.). And more specifically, that the predicate won't throw the IllegalArgumentException if applied to single number, or string.

I came up with the following function, but I'm wondering if there is some more idiomatic approach?

(defn not-empty-coll? [x]
  (and (coll? x) (seq x)))

This will satisfy following tests:

(is (not (not-empty-coll? nil)))    ;; -> false
(is (not (not-empty-coll? 1)))      ;; -> false
(is (not (not-empty-coll? "foo")))  ;; -> false
(is (not (not-empty-coll? [])))     ;; -> nil      (false)
(is (not (not-empty-coll? '())))    ;; -> nil      (false)
(is (not (not-empty-coll? {})))     ;; -> nil      (false)
(is (not-empty-coll? [1]))          ;; -> (1)      (true)
(is (not-empty-coll? '(1)))         ;; -> (1)      (true)
(is (not-empty-coll? {:a 1}))       ;; -> ([:a 1]) (true)

EDIT: A potential use case:

Let's say we need to process some raw external data which are not (yet) under our control. Input could be for example a collection which contains either primitive values, or nested collections. Other example could be a collection holding some inconsistent (maybe broken?) tree structure. So, we can consider mentioned predicate as first line data cleaning.

Otherwise, I agree with comments that is better to explicitly separate and process collection and non-collection data.

Answer 1

As suggested in the comments, I would consider calling not-empty? with a non-collection argument to be an invalid usage, which should generate an IllegalArgumentException .

There is already a function not-empty? available for use in the Tupelo library . Here are the unit tests:

(deftest t-not-empty
  (is (every?      not-empty? ["one" [1] '(1) {:1 1} #{1}     ] ))
  (is (has-none?   not-empty? [ ""   [ ] '( ) {}     #{ }  nil] ))

  (is= (map not-empty? ["1" [1] '(1) {:1 1} #{1} ] )
         [true true true true true]  )
  (is= (map not-empty? ["" [] '() {} #{} nil] )
         [false false false false false false ] )

  (is= (keep-if not-empty?  ["1" [1] '(1) {:1 1} #{1} ] )
                            ["1" [1] '(1) {:1 1} #{1} ] )
  (is= (drop-if not-empty?  [""  []  '()  {}     #{}  nil] )
                            [""  []  '()  {}     #{}  nil] )

  (throws? IllegalArgumentException (not-empty? 5))
  (throws? IllegalArgumentException (not-empty? 3.14)))

---

Update

The preferred approach would be for a function to only receive collection parameters in a given argument, not a mixture scalar & collection arguments. Then, one only needs not-empty given the pre-knowledge that the value in question is not a scalar. I often use Plumatic Schema to enforce this assumption and catch any errors in the calling code:

(ns xyz
  (:require [schema.core :as s] )) ; plumatic schema
(s/defn foo :- [s/Any]
  "Will do bar to the supplied collection"
  [coll :- [s/Any]]
  (if (not-empty coll)
    (mapv bar foo)
    [ :some :default :value ] ))

The 2 uses of notation :- [s/Any] checks that the arg & return value are both declared to be a sequential collection (list or vector). Each element is unrestricted by the s/Any part.

---

If you can't enforce the above strategy for some reason, I would just modify your first approach as follows:

(defn not-empty-coll? [x]
  (and (coll? x) (t/not-empty? x)))

I'm hoping you know at least a little about the param x so the question becomes: Is xa scalar or a non-empty vector. Then you could say something like:

(defn not-empty-coll? [x]
  (and (sequential? x) (t/not-empty? x)))

Answer 2

How about using Clojure protocols and type extensions to solve this?

(defprotocol EmptyCollPred
  (not-empty-coll? [this]))

(extend-protocol EmptyCollPred
  Object
    (not-empty-coll? [this] false)
  nil
    (not-empty-coll? [this] false)
  clojure.lang.Seqable
    (not-empty-coll? [this] (not (empty? (seq this)))))

(is (not (not-empty-coll? nil)))    ;; -> false
(is (not (not-empty-coll? 1)))      ;; -> false
(is (not (not-empty-coll? "foo")))  ;; -> false
(is (not (not-empty-coll? [])))     ;; -> nil      (false)
(is (not (not-empty-coll? '())))    ;; -> nil      (false)
(is (not (not-empty-coll? {})))     ;; -> nil      (false)
(is (not-empty-coll? [1]))          ;; -> (1)      (true)
(is (not-empty-coll? '(1)))         ;; -> (1)      (true)
(is (not-empty-coll? {:a 1}))       ;; -> ([:a 1]) (true)

Maybe it would be cleaner to extend just String and Number instead of Object - depends on what do you know about the incoming data. Also, it would be probably better to filter out nil s beforehand instead of creating a case for it as you see above.

Another - conceptually similar - solution could use multimethods.