Question

我该如何制定仅接受顺序（即保留订单）集合的规范？

例如

cljs.user=> (s/def ::path (s/+ number?))                                                                                                                                                                                 
:cljs.user/path
cljs.user=> (s/explain ::path [])                                                                                                                                                                                                                           
val: () fails spec: :cljs.user/path predicate: number?,  Insufficient input
:cljs.spec.alpha/spec  :cljs.user/path
:cljs.spec.alpha/value  [] 
cljs.user=> (s/explain ::path [1 2 3])                                                                                                                                                                                                                      
Success!

符合预期，但同时请注意顺序

cljs.user=> #{1 2 3}
#{1 3 2}
cljs.user=> (s/explain ::path #{1 2 3})                                                                                                                                                                                                                     
Success!

这似乎没有任何意义。第二个问题：

为什么规范中与序列相关的表达式（cat，*，+ 、?）接受破坏序列的集合？

UPD我在原始问题中弄乱了顺序/有序区分。清理术语。

Answer 1

我该如何制定仅接受订单保留集合的规范？

有一个clojure.core谓词函数sorted?，它将为实现Sorted的集合返回true。

(sorted? (sorted-map))
=> true

对于内容恰好排序但未实现Sorted的集合，它不会返回true：

(sorted? [1 2 3])
=> false

您可以在规范中使用任意谓词函数，因此您可以定义一个对具有排序内容的集合返回true的函数：

(defn ordered? [coll]
  (or (empty? coll) (apply <= coll)))

(ordered? [1 2 3])
=> true

然后，您可以使用s/and将此谓词与您的正则表达式规范结合使用：

(s/def ::path (s/and (s/+ number?)
                     ordered?))

(s/explain ::path [1 2 3])
Success!
=> nil

(s/explain ::path #{1 2 3})
val: [1 3 2] fails spec: :playground.so/path predicate: ordered?
=> nil

Answer 2

序列规范（正则表达式规范）不应与有序匹配，即 sequential 集合。这是当前版本规范中已修复的错误，请参见CLJ-2183。

在Clojure 1.10.0-RC5中，结果符合预期：

(s/conform ::path [1 2 3])   ; => [1 2 3]
(s/conform ::path #{1 2 3})  ; => :clojure.spec.alpha/invalid

(s/explain ::path #{1 2 3})
;; #{1 3 2} - failed: (or (nil? %) (sequential? %)) spec: :user/path

您可以在最后一行看到，正则表达式规范现在仅与sequential?的值匹配。

如何仅接受规范中的有序集合

2 个答案: