Каким способом я предпочитаю проверить, является ли объект пустым списком в Clojure? Обратите внимание, что я хочу проверить только это, а не, если он пуст как последовательность. Если это «ленивый объект» (LazySeq, Iterate, ...), я не хочу, чтобы он получал realized?.
Ниже я приведу несколько возможных тестов для x.
;0
(= clojure.lang.PersistentList$EmptyList (class x))
;1
(and (list? x) (empty? x))
;2
(and (list? x) (zero? (count x)))
;3
(identical? () x)
Тест 0 является немного низким уровнем и основан на «деталях реализации». Моя первая версия была (instance? clojure.lang.PersistentList$EmptyList x), что дает IllegalAccessError. Почему это так? Разве такой тест не возможен?
Тесты 1 и 2 более высокого уровня и более общие, поскольку list? проверяет, реализует ли что-то IPersistentList. Я думаю, они тоже немного менее эффективны. Обратите внимание, что порядок двух под-тестов важен, поскольку мы полагаемся на короткое замыкание.
Тест 3 работает в предположении, что каждый пустой список является одним и тем же объектом. Проведенные мною тесты подтверждают это предположение, но гарантированно ли оно выполнено? Даже если это так, стоит ли полагаться на этот факт?
Все это может показаться тривиальным, но я был немного озадачен тем, что не нашел совершенно простого решения (или даже встроенной функции) для такая простая задача.
update
Возможно, я не очень хорошо сформулировал вопрос. Оглядываясь назад, я понял, что хотел проверить, является ли что-то не ленивой пустой последовательностью. Наиболее важным требованием для моего варианта использования является то, что , если это ленивая последовательность , оно не реализуется, т. Е. никакой толчок не форсируется .
Использование Термин «список» был немного запутанным. Ведь что такое список? Если это что-то конкретное, например PersistentList, то оно не ленивое. Если это что-то абстрактное, например IPersistentList (что проверяет list? и, возможно, правильный ответ), то лень точно не гарантируется. Так уж получилось, что текущие ленивые типы последовательностей Clojure не реализуют этот интерфейс.
Итак, прежде всего мне нужен способ проверить, является ли что-то ленивой последовательностью. Лучшее решение, которое я могу придумать сейчас, - это использовать IPending для проверки лени в целом:
(def lazy? (partial instance? clojure.lang.IPending))
Хотя существуют некоторые типы ленивых последовательностей (например, чанкованные последовательности, такие как Range и LongRange ), которые не реализуют IPending, кажется разумным ожидать, что ленивые последовательности реализуют это вообще. LazySeq делает так, и это действительно имеет значение в моем конкретном c сценарии использования.
Теперь, полагаясь на короткое замыкание, чтобы предотвратить реализацию на empty? (и чтобы дать этому недопустимый аргумент) , у нас есть:
(defn empty-eager-seq? [x] (and (not (lazy? x)) (seq? x) (empty? x)))
Или, если мы знаем, что имеем дело с последовательностями, как в моем случае, мы можем использовать менее ограничительные:
(defn empty-eager? [x] (and (not (lazy? x)) (empty? x)))
Конечно, мы можем писать безопасно тесты для более общих типов, таких как:
(defn empty-eager-coll? [x] (and (not (lazy? x)) (coll? x) (empty? x)))
(defn empty-eager-seqable? [x] (and (not (lazy? x)) (seqable? x) (empty? x)))
При этом рекомендуемый тест 1 также работает для моего случая благодаря короткому замыканию и тому факту, что LazySeq не реализует IPersistentList. Учитывая то, что формулировка вопроса была неоптимальной, я приму краткий ответ Ли и благодарю Алана Томпсона за его время и за полезную мини-дискуссию, которую мы провели с поднятым голосом.