clojure
clojure.spec

वाक्य - विन्यास

• :: एक आशुलिपि एक नेमस्पेस-योग्य कीवर्ड है। जैसे अगर हम नेमस्पेस यूजर में हैं: :: foo इसके लिए एक शॉर्टहैंड है: यूजर / फू
• # या - # - मैप्स-शाब्दिक सिंटैक्स एक नामस्थान द्वारा मानचित्र में कुंजियों को योग्यता के लिए

टिप्पणियों

एक युक्ति के रूप में एक विधेय का उपयोग करना

किसी भी विधेय समारोह का उपयोग एक युक्ति के रूप में किया जा सकता है। यहाँ एक सरल उदाहरण है:

(clojure.spec/valid? odd? 1)
;;=> true

(clojure.spec/valid? odd? 2)
;;=> false

valid? फ़ंक्शन एक युक्ति और एक मूल्य लेगा और सही लौटेगा यदि मूल्य युक्ति के अनुरूप है और अन्यथा गलत है।

एक अन्य दिलचस्प विधेयकों की सदस्यता निर्धारित है:

(s/valid? #{:red :green :blue} :red) 
;;=> true

fdef: किसी फ़ंक्शन के लिए एक कल्पना लिख रहा है

मान लें कि हमारे पास निम्नलिखित कार्य हैं:

(defn nat-num-count [nums] (count (remove neg? nums)))

हम इस फ़ंक्शन के लिए उसी नाम के एक फ़ंक्शन कल्पना को परिभाषित करके एक युक्ति लिख सकते हैं:

(clojure.spec/fdef nat-num-count
        :args (s/cat :nums (s/coll-of number?))
        :ret integer?
        :fn #(<= (:ret %) (-> % :args :nums count)))

:args एक regex युक्ति लेता है जो तर्क नाम और संगत युक्ति के अनुरूप एक कीवर्ड लेबल द्वारा तर्कों के अनुक्रम का वर्णन करता है। कारण जो युक्ति द्वारा आवश्यक है :args एक regex युक्ति है, जो एक फ़ंक्शन के लिए कई आरतियों का समर्थन करता है। :ret फ़ंक्शन के रिटर्न मान के लिए एक युक्ति निर्दिष्ट करता है।

:fn एक युक्ति है जो कि :args और the :ret बीच के संबंध को बाधित करती है। यह एक संपत्ति के रूप में प्रयोग किया जाता है जब test.check के माध्यम से चलाया जाता है। इसे एक एकल तर्क के साथ कहा जाता है: दो कुंजी के साथ एक नक्शा :args (फ़ंक्शन के अनुरूप तर्क) और :ret (फ़ंक्शन के अनुरूप वापसी मूल्य)।

एक युक्ति दर्ज करना

चश्मा के रूप में कामकाज की भविष्यवाणी करने के अलावा, आप clojure.spec/def का उपयोग करके विश्व स्तर पर एक कल्पना पंजीकृत कर सकते हैं। def आवश्यकता है कि पंजीकृत होने वाले एक नाम को नामस्थान-योग्य कीवर्ड द्वारा नाम दिया गया है:

(clojure.spec/def ::odd-nums odd?)
;;=> :user/odd-nums

(clojure.spec/valid? ::odd-nums 1)
;;=> true
(clojure.spec/valid? ::odd-nums 2)
;;=> false

एक बार पंजीकृत होने के बाद, क्लोजर प्रोग्राम में कहीं भी एक युक्ति को विश्व स्तर पर संदर्भित किया जा सकता है।

user नामस्थान में हैं: यह मानते हुए कि :user/odd-nums ::odd-nums सिंटैक्स :user/odd-nums :: उस प्रतीक को योग्य करेगा जिसे वह वर्तमान नाम के साथ रखता है।

विधेय में पारित होने के बजाय, हम valid? नाम में valid? करने के लिए पारित कर सकते हैं valid? , और यह उसी तरह काम करेगा।

clojure.spec / और & clojure.spec / या

clojure.spec/and & clojure.spec/or कई स्पेक्स या विधेयकों का उपयोग करके अधिक जटिल चश्मा बनाने के लिए उपयोग किया जा सकता है:

(clojure.spec/def ::pos-odd (clojure.spec/and odd? pos?))

(clojure.spec/valid? ::pos-odd 1)
;;=> true

(clojure.spec/valid? ::pos-odd -3)
;;=> false

or एक महत्वपूर्ण अंतर के साथ इसी तरह काम करता है। or युक्ति को परिभाषित करते समय, आपको प्रत्येक संभावित शाखा को एक खोजशब्द के साथ टैग करना चाहिए। इसका उपयोग विशिष्ट शाखाओं को प्रदान करने के लिए किया जाता है जो त्रुटि संदेशों में विफल रहती हैं:

(clojure.spec/def ::big-or-small (clojure.spec/or :small #(< % 10) :big #(> % 100)))

(clojure.spec/valid? ::big-or-small 1)
;;=> true

(clojure.spec/valid? ::big-or-small 150)
;;=> true

(clojure.spec/valid? ::big-or-small 20)
;;=> false

उपयोग करते समय किसी युक्ति के अनुरूप or , लागू किए गए युक्ति को लौटा दिया जाएगा जिसने मूल्य अनुरूप बनाया:

(clojure.spec/conform ::big-or-small 5)
;; => [:small 5]

रिकॉर्ड चश्मा

आप निम्नानुसार एक रिकॉर्ड निर्दिष्ट कर सकते हैं:

(clojure.spec/def ::name string?)
(clojure.spec/def ::age pos-int?)
(clojure.spec/def ::occupation string?)

(defrecord Person [name age occupation])

(clojure.spec/def ::person (clojure.spec/keys :req-un [::name ::age ::occupation]))

(clojure.spec/valid? ::person (->Person "john doe" 25 "programmer"))
;;=> true

(clojure.spec/valid? ::person (->Person "john doe" "25" "programmer"))
;;=> false

भविष्य में कुछ बिंदुओं पर, रिकॉर्ड्स नेमस्पेस द्वारा योग्यता रिकॉर्ड कुंजी के लिए एक रीडर सिंटैक्स या अंतर्निहित समर्थन पेश किया जा सकता है। यह समर्थन नक्शे के लिए पहले से मौजूद है।

नक्शा चश्मा

आप मानचित्र में निर्दिष्ट कर सकते हैं कि नक्शे में कौन सी कुंजियाँ होनी चाहिए:

(clojure.spec/def ::name string?)
(clojure.spec/def ::age pos-int?)
(clojure.spec/def ::occupation string?)

(clojure.spec/def ::person (clojure.spec/keys :req [::name ::age ::occupation]))

(clojure.spec/valid? ::person {::name "john" ::age 25 ::occupation "programmer"})
;; => true

:req मानचित्र में उपस्थित होने के लिए आवश्यक की एक वेक्टर है। आप अतिरिक्त विकल्प निर्दिष्ट कर सकते हैं जैसे :opt , कुंजियों का एक वेक्टर जो वैकल्पिक है।

अब तक के उदाहरणों के लिए आवश्यक है कि नाम में कुंजियाँ नाम-स्थान-योग्य हों। लेकिन मानचित्र कुंजियों के अयोग्य होने के लिए यह सामान्य है। इस स्थिति के लिए, clojure.spec प्रदान करता है: अयोग्य और अयोग्य कुंजी के लिए ऑप्ट समकक्ष:: clojure.spec :req-un और :opt-un । यहाँ एक ही उदाहरण है, अयोग्य कुंजी के साथ:

(clojure.spec/def ::name string?)
(clojure.spec/def ::age pos-int?)
(clojure.spec/def ::occupation string?)

(clojure.spec/def ::person (clojure.spec/keys :req-un [::name ::age ::occupation]))

(clojure.spec/valid? ::person {:name "john" :age 25 :occupation "programmer"})
;; => true

ध्यान दें कि कैसे प्रदान की गई चश्मा :req-un वेक्टर अभी भी योग्य है। clojure.spec, मूल्यों के अनुरूप होने पर मानचित्र में अयोग्य संस्करणों की स्वचालित रूप से पुष्टि करेगा।

नेमस्पेस मानचित्र शाब्दिक वाक्य-विन्यास आपको एक सिंगल नेमस्पेस द्वारा नक्शे की सभी कुंजियों को योग्य रूप से योग्य बनाने की अनुमति देता है। उदाहरण के लिए:

(clojure.spec/def ::name string?)
(clojure.spec/def ::age pos-int?)
(clojure.spec/def ::occupation string?)

(clojure.spec/def ::person (clojure.spec/keys :req [::name ::age ::occupation]))

(clojure.spec/valid? ::person #:user{:name "john" :age 25 :occupation "programmer"})
;;=> true

विशेष #: पाठक वाक्यविन्यास। हम इस नामस्थान के साथ अनुसरण करते हैं, जिसके द्वारा हम सभी मानचित्र कुंजियों को अर्हता प्राप्त करना चाहते हैं। इसके बाद प्रदान किए गए नाम स्थान के अनुरूप स्पेक्स के खिलाफ जांच की जाएगी।

संग्रह

आप कई तरीकों से संग्रह की कल्पना कर सकते हैं। Coll-to आपको संग्रह की कल्पना करने और कुछ अतिरिक्त बाधाओं को प्रदान करने की अनुमति देता है। यहाँ एक सरल उदाहरण है:

(clojure.spec/valid? (clojure.spec/coll-of int?) [1 2 3])
;; => true

(clojure.spec/valid? (clojure.spec/coll-of int?) '(1 2 3))
;; => true

संग्रह के लिए बाधा विकल्प मुख्य कल्पना / भविष्यवाणी का पालन करते हैं। आप इस :kind के संग्रह प्रकार को बाधित कर सकते हैं:

(clojure.spec/valid? (clojure.spec/coll-of int? :kind vector?) [1 2 3])
;; => true

(clojure.spec/valid? (clojure.spec/coll-of int? :kind vector?) '(1 2 3))
;; => false

उपरोक्त गलत है क्योंकि संग्रह में पास किया गया वेक्टर नहीं है।

(clojure.spec/valid? (clojure.spec/coll-of int? :kind list?) '(1 2 3))
;; => true

(clojure.spec/valid? (clojure.spec/coll-of int? :kind set?) #{1 2 3})
;; => true

(clojure.spec/valid? (clojure.spec/coll-of int? :kind set?) #{1 "2" 3})
;; => false

उपरोक्त गलत है क्योंकि सेट में सभी तत्व नहीं हैं।

आप कुछ तरीकों से संग्रह के आकार को भी बाधित कर सकते हैं:

(clojure.spec/valid? (clojure.spec/coll-of int? :kind vector? :count 3) [1 2 3])
;; => true

    (clojure.spec/valid? (clojure.spec/coll-of int? :kind vector? :count 3) [1 2])
;; => false

(clojure.spec/valid? (clojure.spec/coll-of int? :min-count 3 :max-count 5) [1 2 3])
;; => true

    (clojure.spec/valid? (clojure.spec/coll-of int? :min-count 3 :max-count 5) [1 2])
;; => false

तुम भी संग्रह में तत्वों की विशिष्टता के साथ लागू कर सकते हैं :distinct :

(clojure.spec/valid? (clojure.spec/coll-of int? :distinct true) [1 2])
;; => true

(clojure.spec/valid? (clojure.spec/coll-of int? :distinct true) [2 2])
;; => false

coll-of सुनिश्चित एक क्रम में सभी तत्वों को जाँच कर रहे हैं। बड़े संग्रह के लिए, यह बहुत अक्षम हो सकता है। every व्यवहार coll-of तरह ही coll-of , सिवाय इसके कि वह अनुरूपता के लिए अपेक्षाकृत कम संख्या में अनुक्रमों के तत्वों का नमूना लेता है। यह बड़े संग्रह के लिए अच्छी तरह से काम करता है। यहाँ एक उदाहरण है:

(clojure.spec/valid? (clojure.spec/every int? :distinct true) [1 2 3 4 5])
;; => true

map-of का coll-of समान है, लेकिन नक्शे के लिए। चूंकि नक्शों में कुंजी और मूल्य दोनों होते हैं, इसलिए आपको कुंजी के लिए एक युक्ति और मूल्य के लिए एक युक्ति दोनों की आपूर्ति करनी चाहिए:

(clojure.spec/valid? (clojure.spec/map-of keyword? string?) {:red "red" :green "green"})
;; => true

जैसे coll-of , map-of चेक्स सभी मैप की / मानों के अनुरूप होते हैं। बड़े मानचित्रों के लिए यह अक्षम होगा। coll-of , map-of सप्लाई की तरह every-kv को कुशलता से एक बड़े मैप से अपेक्षाकृत कम संख्या में सैंपलिंग के लिए:

(clojure.spec/valid? (clojure.spec/every-kv keyword? string?) {:red "red" :green "green"})
;; => true

दृश्यों

युक्ति वर्णन कर सकती है और मनमाने दृश्यों के साथ प्रयोग की जा सकती है। यह कई रेगेक्स स्पेक ऑपरेशंस के जरिए इसका समर्थन करता है।

(clojure.spec/valid? (clojure.spec/cat :text string? :int int?) ["test" 1])
;;=> true

अनुक्रम का वर्णन करने के लिए उपयोग की जाने वाली प्रत्येक युक्ति के लिए cat को लेबल की आवश्यकता होती है। बिल्ली तत्वों का एक क्रम और प्रत्येक के लिए एक युक्ति का वर्णन करती है।

alt का उपयोग किसी दिए गए तत्व के लिए कई अनुक्रमों में एक क्रम में चुनने के लिए किया जाता है। उदाहरण के लिए:

(clojure.spec/valid? (clojure.spec/cat :text-or-int (clojure.spec/alt :text string? :int int?)) ["test"])
;;=> true

alt यह भी आवश्यक है कि प्रत्येक युक्ति एक कीवर्ड द्वारा लेबल की गई हो।

रेगेक्स अनुक्रमों को मनमाने ढंग से जटिल अनुक्रम-वर्णन करने वाले चश्मे बनाने के लिए कुछ बहुत ही रोचक और शक्तिशाली तरीकों से बनाया जा सकता है। यहां थोड़ा और जटिल उदाहरण दिया गया है:

(clojure.spec/def ::complex-seq (clojure.spec/+ (clojure.spec/cat :num int? :foo-map (clojure.spec/map-of keyword? int?))))
(clojure.spec/valid? ::complex-seq [0 {:foo 3 :baz 1} 4 {:foo 4}])
;;=> true

यहां ::complex-seq तत्वों के एक या अधिक जोड़े के अनुक्रम को मान्य करेगा, पहला एक int और दूसरा int करने के लिए कीवर्ड का एक मानचित्र है।