甲Clojure的规格相匹配，并生成可变长度

Question

的有序向量允许在开始时的

(require '[clojure.spec  :as spec] 
     '[clojure.spec.gen :as gen]) 
(spec/def ::cat (spec/cat :sym symbol? :str string? :kws (spec/* keyword?))) 

正规序列的载体

(spec/conform ::cat '[af "5"]) 
=> {:sym af, :str "5"} 
(spec/conform ::cat '[af "5" :key]) 
=> {:sym af, :str "5", :kws [:key]} 

而且列表

匹配

(spec/conform ::cat '(af "5")) 
=> {:sym af, :str "5"} 
(spec/conform ::cat '(af "5" :key)) 
=> {:sym af, :str "5", :kws [:key]} 

如果我们想限制这个，我们可以尝试使用spec/tuple;但遗憾的是它只匹配固定长度的矢量，即它需要在至少一个空列表是元组的最后一部分：

(spec/def ::tuple (spec/tuple symbol? string? (spec/* keyword?))) 
(spec/conform ::tuple '[af "5"]) 
=> :clojure.spec/invalid 
(spec/exercise ::tuple) 
=> ([[r ""()] [r "" []]] [[kE "" (:M)] [kE "" [:M]]] ...) 

我们也可以尝试添加一个额外条件::cat与spec/and：

(spec/def ::and-cat 
    (spec/and vector? (spec/cat :sym symbol? :str string? :kws (spec/* keyword?)))) 

它匹配精细

(spec/conform ::and-cat '[af "5"]) 
=> {:sym af, :str "5"} 
(spec/conform ::and-cat '[af "5" :key]) 
=> {:sym af, :str "5", :kws [:key]} 
(spec/conform ::and-cat '(af "5" :key)) 
=> :clojure.spec/invalid 

但遗憾的是未能在产生自发电机它自己的数据只生产这当然不符合vector?谓词列表：

(spec/exercise ::and-cat) 
=> Couldn't satisfy such-that predicate after 100 tries. 

所以总结：一个人如何写一个测试，这是双方能够接受和产生像[hi "there"][my "dear" :friend]载体？

也可以将问题改为“是否有替代spec/cat的替代产生向量”？或者“是否有可能将一个友好的论点传递给spec/cat？”或者“我可以将发生器附加到一个规格中，该规格将原始发生器的输出并将其转换为矢量？”。

Answer 1

创建一个从规格独立于正则表达式模式：

(require '[clojure.spec :as s] '[clojure.spec.gen :as gen]) 

(def pattern 
    (s/cat :sym symbol? :str string? :kws (s/* keyword?))) 

(s/def ::solution 
    (s/with-gen (s/and vector? pattern) 
       #(gen/fmap vec (spec/gen pattern)))) 

(s/valid? ::solution '(af "5" :key)) ;; false 

(s/valid? ::solution ['af "5" :key]) ;; true 

(gen/sample (s/gen ::solution) 4) 
;; ([m ""] [. "" :Q] [- "" :?-/-9y :_7*/!] [O._7l/.?*+ "z" :**Q.tw.!_/+!gN :wGR/K :n/L]) 

Answer 2

从clojure-1.9.0-alpha15开始解决这个问题的方法并不简单。一个可能的解决方案是修改发电机投由猫中给出的序列到像载体：

(spec/def ::solution 
    (let [s (spec/cat :sym symbol? :str string? :kws (spec/* keyword?))] 
    (spec/with-gen s #(gen/fmap vec (spec/gen s))))) 

然后我们可以看到两个产生并接受正确的数据：

(spec/exercise ::solution) 
=> ([[T ""] {:sym T, :str ""}] 
    [[t* "Z" :g*] {:sym t*, :str "Z", :kws [:g*]}] 
    [[G?8 "td" :*K/j] {:sym G?8, :str "td", :kws [:*K/j]}]) 

虽然它有一个问题，规范没有验证该输入是一个向量，它接受序列如列表：

(spec/conform ::solution '(N-G.?8?4/- "" :G7y_.?Gx_/Oy1Dv :g!/Ooh0 :N-??h/o+cN)) 
=> {:sym N-G.?8?4/-, :str "", :kws [:G7y_.?Gx_/Oy1Dv :g!/Ooh0 :N-??h/o+cN]} 

Answer 3

要在Alex的解决方案添加，这里是它定义了一个矢量猫正则表达式操作的宏：

(defmacro vcat 
    "Takes key+pred pairs, e.g. 

    (vcat :e even? :o odd?) 

    Returns a regex op that matches vectors, returning a map containing 
    the keys of each pred and the corresponding value. The attached 
    generator produces vectors." 
    [& key-pred-forms] 
    `(spec/with-gen (spec/and vector? (spec/cat ~@key-pred-forms)) 
    #(gen/fmap vec (spec/gen (spec/cat ~@key-pred-forms)))))