हाई - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

हाई - हाई दस्तावेज़ीकरण [छवि: हाई] [छवि]

Thử Hy https://try-hy.appspot.com

PyPI https://pypi.python.org/pypi/hy

स्रोत https://github.com/hylang/hy

सूची हिलैंग-चर्चा

आईआरसी #हाय फ़्रीनोड पर

बनाएँ हैसियत
ट्रेविस CI.अनइंडेंट

हाई लिस्प की एक अद्भुत बोली है जो पायथन में अंतर्निहित है।

चूंकि Hy अपने लिस्प कोड को पायथन एब्सट्रैक्ट सिंटेक्स ट्री में बदल देता है, आपके पास है
पाइथॉन की पूरी खूबसूरत दुनिया आपकी उंगलियों पर, लिस्प रूप में!

सामग्री:

जल्दी शुरू

[छवि: करेन रस्टर्ड के कडल्स] [छवि]

(आलिंगन के लिए करेन रुस्तद को धन्यवाद!)

कैसे सेवा मेरे GET HY असली फास्ट:

1। बनाओ वास्तविक अजगर वातावरण.

2. अपने वर्चुअल पायथन वातावरण को सक्रिय करें।

3। स्थापित करें hy से PyPI साथ में रंज स्थापित hy.

4. इसके साथ एक REPL प्रारंभ करें hy.

5. आरईपीएल में सामान टाइप करें:

=> (प्रिंट "हाय!")
हाय!
=> (defn salutationsnm [नाम] (प्रिंट (+ "हाय " नाम "!")))
=> (प्रणाम एनएम "आपका नाम")
नमस्ते आपका नाम!

आदि

6. जब आपका काम पूरा हो जाए तो CTRL-D दबाएँ।

OMG! यही कारण है कि गजब का! I करना चाहते हैं सेवा मेरे लिखना a Hy कार्यक्रम.

7. एक विशिष्ट प्रोग्रामिंग संपादक खोलें और टाइप करें:

(प्रिंट करें "मैं पायथन सिंटैक्स में कोड करने जा रहा था, लेकिन फिर मुझे Hy मिल गया।")

8. इस रूप में सहेजें बहुत बढ़िया.हाय.

9. और अपना पहला हाई प्रोग्राम चलाएँ:

हाय बहुत बढ़िया.हाय

10.
गहरी सांस लें ताकि हाइपरवेंटिलेट न हो।

11.
खलनायक की तरह मुस्कुराएं और चुपचाप अपने ठिकाने पर चले जाएं और अकथनीय चीजें करें।

ट्यूटोरियल

हाई ट्यूटोरियल में आपका स्वागत है!

संक्षेप में, Hy एक लिस्प बोली है, लेकिन वह इसकी संरचना को पायथन में बदल देती है...
वस्तुतः पायथन के अमूर्त वाक्यविन्यास वृक्ष में रूपांतरण! (या इसे और अधिक क्रूड में डालने के लिए
शब्दों में, हाई एक पायथन पर तुतलाना-छड़ी है!)

यह बहुत बढ़िया है क्योंकि इसका मतलब है कि Hy कई चीजें हैं:

· एक लिस्प जो बहुत पाइथोनिक लगता है

· लिस्पर्स के लिए, लिस्प की पागल शक्तियों का उपयोग करने का एक शानदार तरीका लेकिन पायथन की विस्तृत दुनिया में
लाइब्रेरीज़ (हाँ क्यों, अब आप लिस्प में Django एप्लिकेशन लिख सकते हैं!)

· पायथॉनिस्टस के लिए, पायथॉन के आराम से लिस्प की खोज शुरू करने का एक शानदार तरीका!

· हर किसी के लिए: एक सुखद भाषा जिसमें बहुत सारे साफ-सुथरे विचार हों!

बुनियादी परिचय सेवा मेरे तुतलाना एसटी पाइथोनिस्टास
ठीक है, हो सकता है कि आपने पहले कभी लिस्प का उपयोग नहीं किया हो, लेकिन आपने पायथन का उपयोग किया है!

हाई में "हैलो वर्ल्ड" कार्यक्रम वास्तव में बहुत सरल है। चलो यह कोशिश करते हैं:

(प्रिंट "हैलो वर्ल्ड")

देखना? आसान! जैसा कि आपने अनुमान लगाया होगा, यह इसके पायथन संस्करण के समान है:

"हैलो वर्ल्ड" प्रिंट करें

कुछ अत्यंत सरल गणित जोड़ने के लिए, हम यह कर सकते हैं:

(+1 3)

जो 4 लौटाएगा और इसके बराबर होगा:

1 + 3

आप देखेंगे कि सूची में पहला आइटम वह फ़ंक्शन है जिसे कॉल किया जा रहा है और
बाकी तर्क पारित किए जा रहे तर्क हैं। वास्तव में, हाई में (जैसा कि अधिकांश के साथ होता है)।
लिस्प्स) हम प्लस ऑपरेटर को कई तर्क दे सकते हैं:

(+ 1 3 55)

जो 59 लौटाएगा।

हो सकता है कि आपने पहले लिस्प के बारे में सुना हो लेकिन इसके बारे में ज्यादा नहीं जानते हों। लिस्प आपके जितना कठिन नहीं है
सोच सकते हैं, और Hy को Python से विरासत में मिला है, इसलिए Hy लिस्प सीखना शुरू करने का एक शानदार तरीका है।
लिस्प के बारे में मुख्य बात जो स्पष्ट है वह यह है कि इसमें बहुत सारे कोष्ठक हैं। संभवत: यह
पहली बार में यह भ्रमित करने वाला लगता है, लेकिन यह इतना कठिन नहीं है। आइए कुछ सरल गणित पर नजर डालें
कोष्ठकों के एक समूह में लपेटा गया है जिसे हम हाई दुभाषिया में दर्ज कर सकते हैं:

(सेटव परिणाम (- (/ (+ 1 3 88) 2) 8))

यह 38 लौटाएगा। लेकिन क्यों? खैर, हम समतुल्य अभिव्यक्ति को देख सकते हैं
अजगर:

परिणाम = ((1 + 3 + 88)/2) - 8

यदि आपको यह पता लगाने की कोशिश करनी है कि उपरोक्त पायथन में कैसे काम करेगा, तो आप निश्चित रूप से ऐसा करेंगे
प्रत्येक आंतरिक कोष्ठक को हल करके परिणाम निकालें। में भी यही मूल विचार है
हाय. आइए पहले इस अभ्यास को पायथन में आज़माएँ:

परिणाम = ((1 + 3 + 88)/2) - 8
#सरलीकृत...
परिणाम = (92/2) - 8
#सरलीकृत...
परिणाम = 46 - 8
#सरलीकृत...
परिणाम = १

आइए अब यही चीज़ Hy में आज़माएँ:

(सेटव परिणाम (- (/ (+ 1 3 88) 2) 8))
; को सरल बनाया गया...
(सेटव परिणाम (- (/92 2)8))
; को सरल बनाया गया...
(सेटव परिणाम (- 46 8))
; को सरल बनाया गया...
(सेटव परिणाम 38)

जैसा कि आपने शायद अनुमान लगाया होगा, यह अंतिम अभिव्यक्ति है setv वेरिएबल निर्दिष्ट करने का मतलब है
38 तक "परिणाम"।

देखना? बहुत कठोर नहीं!

यह लिस्प का मूल आधार है। लिस्प का अर्थ "सूची प्रसंस्करण" है; इसका मतलब यह है कि
कार्यक्रम की संरचना वास्तव में सूचियों की सूची है। (यदि आप पायथन से परिचित हैं
सूचियाँ, उपरोक्त के समान संपूर्ण संरचना की कल्पना करें, लेकिन इसके बजाय वर्गाकार कोष्ठक के साथ, कोई भी
आप उपरोक्त संरचना को प्रोग्राम और डेटास्ट्रक्चर दोनों के रूप में देख पाएंगे।) यह है
अधिक उदाहरणों से समझना आसान है, तो आइए एक सरल पायथन प्रोग्राम लिखें, इसका परीक्षण करें,
और फिर समकक्ष हाई प्रोग्राम दिखाएं:

def सरल_बातचीत():
प्रिंट करें "हैलो! मैं आपको जानना चाहता हूं। मुझे अपने बारे में बताएं!"
नाम = raw_input ("आपका नाम क्या है?")
उम्र = raw_input ("आपकी उम्र क्या है?")
"हैलो" + नाम + "प्रिंट करें! मैं देख रहा हूं कि आपकी उम्र" + आयु + "वर्ष है।"

सरल_बातचीत()

यदि हम यह प्रोग्राम चलाते हैं, तो यह इस प्रकार हो सकता है:

नमस्ते! मैं तुमको जानना चाहूँगा। मुझे अपने बारे में बताओ!
आपका क्या नाम है? गैरी
तुम्हारी उम्र क्या है? 38
नमस्ते गैरी! मैं देख रहा हूं कि आप 38 साल के हैं.

आइए अब समकक्ष हाई प्रोग्राम को देखें:

(सरल-बातचीत को परिभाषित करें []
(प्रिंट करें "हैलो! मैं आपको जानना चाहता हूं। मुझे अपने बारे में बताएं!")
(सेटव नाम (रॉ-इनपुट "आपका नाम क्या है?"))
(सेटव उम्र (रॉ-इनपुट "आपकी उम्र क्या है?"))
(प्रिंट करें (+ "हैलो" नाम "! मैं देख रहा हूं आप हैं")
उम्र "वर्ष पुराना.")))

(सरल-बातचीत)

यदि आप उपरोक्त कार्यक्रम को देखते हैं, जब तक आपको याद है कि प्रत्येक में पहला तत्व
प्रोग्राम की सूची में फ़ंक्शन (या मैक्रो... हम उन पर बाद में चर्चा करेंगे) को कॉल किया जा रहा है
और यह कि बाकी तर्क हैं, यह समझना बहुत आसान है कि इसका क्या मतलब है।
(जैसा कि आपने शायद अनुमान भी लगाया होगा, रक्षा तरीकों को परिभाषित करने की हाई विधि है।)

फिर भी, बहुत से लोगों को यह पहली बार में भ्रमित करने वाला लगता है क्योंकि इसमें बहुत सारे कोष्ठक हैं,
लेकिन ऐसी बहुत सी चीजें हैं जो इसे आसान बनाने में मदद कर सकती हैं: इंडेंटेशन को अच्छा रखें और
कोष्ठक मिलान वाले संपादक का उपयोग करें (इससे आपको यह पता लगाने में मदद मिलेगी कि प्रत्येक क्या है)।
कोष्ठक जोड़े के साथ) और चीजें सहज महसूस होने लगेंगी।

कोड संरचना के कुछ फायदे हैं जो वास्तव में एक बहुत ही सरल डेटा है
लिस्प का मूल संरचना पर आधारित है। एक बात के लिए, इसका मतलब है कि आपके कार्यक्रम हैं
विश्लेषण करना आसान है और कार्यक्रम की संपूर्ण वास्तविक संरचना बहुत स्पष्ट रूप से सामने आती है
आपको। (हाय में एक अतिरिक्त कदम है जहां आप जो संरचना देखते हैं उसे पायथन में परिवर्तित कर दिया जाता है
स्वयं का प्रतिनिधित्व ... "शुद्ध" लिस्प जैसे कॉमन लिस्प या एमएसीएस लिस्प में, डेटा
कोड में आप जो संरचना देखते हैं और जो डेटा संरचना निष्पादित होती है, वह बहुत अधिक है
वस्तुतः बंद।)

इसका एक अन्य निहितार्थ मैक्रोज़ है: यदि किसी प्रोग्राम की संरचना एक साधारण डेटा है
संरचना, इसका मतलब है कि आप ऐसे कोड लिख सकते हैं जो कोड को बहुत आसानी से लिख सकते हैं, अर्थात
पूरी तरह से नई भाषा सुविधाओं को लागू करना बहुत तेज़ हो सकता है। हाई से पहले, ऐसा नहीं था
पायथन प्रोग्रामर्स के लिए बहुत संभव है... अब आप भी मैक्रोज़ के अविश्वसनीय का उपयोग कर सकते हैं
शक्ति (बस सावधान रहें कि उनका निशाना पैदल न हो)!

Hy is a लिस्प-स्वाद वाला अजगर
Hy, Python के अपने अमूर्त सिंटैक्स ट्री में परिवर्तित हो जाता है, इसलिए आपको जल्द ही वह सब मिलना शुरू हो जाएगा
अजगर की परिचित शक्ति आपकी उंगलियों पर है।

आपके पास पायथन के डेटा प्रकारों और हाई में मानक लाइब्रेरी तक पूर्ण पहुंच है। आइए प्रयोग करें
हाई दुभाषिया में इसके साथ:

=> [1 2 3]
[1, 2, 3]
=> {"कुत्ता" "भौंकना"
... "बिल्ली" "म्याऊ"}
...
{'कुत्ता': 'भौंकना', 'बिल्ली': 'म्याऊं'}
=> (, 1 2 3)
(1, 2, 3)

यदि आप अन्य लिस्प्स से परिचित हैं, तो आपको रुचि हो सकती है कि हाई कॉमन का समर्थन करता है
उद्धृत करने की लिस्प विधि:

=> '(1 2 3)
(1एल 2एल 3एल)

आपके पास सभी अंतर्निहित प्रकारों की अच्छी विधियों तक भी पहुंच है:

=> (.स्ट्रिप " fooooo ")
"फूउउ"

यह क्या है? हाँ वास्तव में, यह बिल्कुल वैसा ही है:

" fooooo ".strip()

यह सही है --- डॉट नोटेशन के साथ लिस्प! यदि हमारे पास यह स्ट्रिंग एक वेरिएबल के रूप में निर्दिष्ट है, तो हम
निम्नलिखित भी कर सकते हैं:

(सेटव दिस-स्ट्रिंग "फूउउ")
(यह-स्ट्रिंग.स्ट्रिप)

सशर्तों के बारे में क्या?:

(अगर (कोशिश-कुछ-कुछ)
(प्रिंट करें "यह सच है")
(प्रिंट करें "यह यदि गलत है"))

जैसा कि आप ऊपर बता सकते हैं, पहला तर्क if एक सत्य परीक्षण है, दूसरा तर्क है
मुख्य भाग यदि सत्य है, और तीसरा तर्क (वैकल्पिक!) यदि गलत है (अर्थात्। अन्य).

यदि आपको अधिक जटिल सशर्त कार्य करने की आवश्यकता है, तो आप पाएंगे कि आपके पास ऐसा नहीं है elif
हाई में उपलब्ध है. इसके बजाय, आपको नामक किसी चीज़ का उपयोग करना चाहिए cond. पायथन में, आप कर सकते हैं
कुछ इस तरह:

किसी दिन = 33
यदि किसी दिन > 50:
प्रिंट करें "वह चर बहुत बड़ा है!"
एलिफ़ किसी दिन <10:
प्रिंट करें "वह वेरिएबल बहुत छोटा है!"
अन्य:
प्रिंट करें "वह वेरिएबल बिल्कुल सही है!"

हाई में, आप करेंगे:

(शर्त
[(>किसी वर्ष 50)
(प्रिंट करें "वह चर बहुत बड़ा है!")]
[(<किसी दिन 10)
(प्रिंट करें "वह चर बहुत छोटा है!")]
[सत्य
(प्रिंट करें "वह वैरिएबल बिल्कुल सही है!")])

आप जो नोटिस करेंगे वह यह है cond निष्पादित किए गए कुछ कथनों के बीच स्विच ऑफ हो जाता है
सत्य या असत्य के लिए सशर्त रूप से जाँच की जाती है, और यदि यह बदल जाता है तो निष्पादित करने के लिए थोड़ा सा कोड
सच निकला. आप यह भी देखेंगे कि अन्य अंत में बस द्वारा कार्यान्वित किया जाता है
के लिए जाँच <strong>उद्देश्य</strong> -- ऐसा है क्योंकि <strong>उद्देश्य</strong> हमेशा सत्य होगा, इसलिए यदि हम यहां तक ​​पहुंच गए, तो हम ऐसा करेंगे
उसे हमेशा चलाओ!

यदि आपके पास इस प्रकार का कोड है तो आप इसे ऊपर देख सकते हैं:

(यदि कुछ शर्त
(शरीर-यदि-सत्य)
(शरीर-यदि-झूठा))

पर रुको! यदि आप किसी एक के मुख्य भाग में एक से अधिक कथन निष्पादित करना चाहते हैं तो क्या होगा?
इन?

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

(अगर (कोशिश-कुछ-कुछ)
(का
(प्रिंट करें "यह सच है")
(प्रिंट "और क्यों नहीं, आइए बात करते रहें कि यह कितना सच है!))
(प्रिंट करें "यह अभी भी बिल्कुल गलत है"))

आप देख सकते हैं कि हमने प्रयोग किया do एकाधिक कथनों को लपेटने के लिए। यदि आप दूसरे से परिचित हैं
लिस्प्स, यह के बराबर है prog कहीं.

टिप्पणियाँ अर्धविराम से शुरू होती हैं:

(प्रिंट करें "यह चलेगा")
; (प्रिंट करें "लेकिन ऐसा नहीं होगा")
(+ 1 2 3) ; हम जोड़ निष्पादित करेंगे, लेकिन यह टिप्पणी नहीं!

लूपिंग कठिन नहीं है बल्कि एक प्रकार की विशेष संरचना होती है। पायथन में, हम यह कर सकते हैं:

मेरे लिए में रेंज(10)
प्रिंट करें "'i' अब " + str(i) पर है

Hy में समतुल्य होगा:

([i (रेंज 10) के लिए]
(प्रिंट करें (+ "'i' अब " (str i)) पर है))

आप विभिन्न पायथन पुस्तकालयों का आयात और उपयोग भी कर सकते हैं। उदाहरण के लिए:

(आयात ओएस)

(यदि (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/anotherdir")
(प्रिंट करें "अरे, वह रास्ता वहां नहीं है!"))

पायथन के संदर्भ प्रबंधक (साथ में कथन) का उपयोग इस प्रकार किया जाता है:

([[f के साथ (खुला "/tmp/data.in")]]
(प्रिंट (.पढ़ें एफ)))

जो इसके बराबर है:

f के रूप में open("/tmp/data.in") के साथ:
प्रिंट f.read()

और हाँ, हमारे पास सूची की समझ है! पायथन में आप यह कर सकते हैं:

विषम_वर्ग = [
पाउ(संख्या, 2)
संख्या में के लिए रेंज(100)
यदि संख्या % 2 == 1]

हाई में, आप ये कर सकते हैं:

(सेटव ऑड्स-स्क्वेर्ड
(सूची-कॉम्प
(पाउ संख्या 2)
(संख्या (श्रेणी 100))
(= (% संख्या 2)1)))

; और, क्लोजर पेज से बेशर्मी से चुराया गया एक उदाहरण:
; आइए शतरंज की बिसात के सभी ब्लॉकों की सूची बनाएं:

(सूची-कॉम्प
(, xy)
(एक्स (रेंज 8)
वाई "एबीसीडीईएफजीएच"))

; [(0, 'ए'), (0, 'बी'), (0, 'सी'), (0, 'डी'), (0, 'ई'), (0, 'एफ'), ( 0, 'जी'), (0, 'एच'),
; (1, 'ए'), (1, 'बी'), (1, 'सी'), (1, 'डी'), (1, 'ई'), (1, 'एफ'), (1 , 'जी'), (1, 'एच'),
; (2, 'ए'), (2, 'बी'), (2, 'सी'), (2, 'डी'), (2, 'ई'), (2, 'एफ'), (2 , 'जी'), (2, 'एच'),
; (3, 'ए'), (3, 'बी'), (3, 'सी'), (3, 'डी'), (3, 'ई'), (3, 'एफ'), (3 , 'जी'), (3, 'एच'),
; (4, 'ए'), (4, 'बी'), (4, 'सी'), (4, 'डी'), (4, 'ई'), (4, 'एफ'), (4 , 'जी'), (4, 'एच'),
; (5, 'ए'), (5, 'बी'), (5, 'सी'), (5, 'डी'), (5, 'ई'), (5, 'एफ'), (5 , 'जी'), (5, 'एच'),
; (6, 'ए'), (6, 'बी'), (6, 'सी'), (6, 'डी'), (6, 'ई'), (6, 'एफ'), (6 , 'जी'), (6, 'एच'),
; (7, 'ए'), (7, 'बी'), (7, 'सी'), (7, 'डी'), (7, 'ई'), (7, 'एफ'), (7 , 'जी'), (7, 'एच')]

पायथन के पास विभिन्न फैंसी तर्क और कीवर्ड तर्कों के लिए समर्थन है। पायथन में हम कर सकते हैं
देख:

>>> def वैकल्पिक_arg(pos1, pos2, कीवर्ड1=कोई नहीं, कीवर्ड2=42):
... वापसी [pos1, pos2, कीवर्ड1, कीवर्ड2]
...
>>> वैकल्पिक_arg(1, 2)
[1, 2, कोई नहीं, 42]
>>> वैकल्पिक_arg(1, 2, 3, 4)
[०, २, १, ०]
>>> वैकल्पिक_arg(कीवर्ड1=1, पॉस2=2, पॉस1=3, कीवर्ड2=4)
[०, २, १, ०]

हाई में भी यही बात:

=> (वैकल्पिक-आर्ग को परिभाषित करें [pos1 pos2 और वैकल्पिक कीवर्ड1 [कीवर्ड2 42]]
... [pos1 pos2 कीवर्ड1 कीवर्ड2])
=> (वैकल्पिक-आर्ग 1 2)
[1 2 कोई नहीं 42]
=> (वैकल्पिक-आर्ग 1 2 3 4)
[1 2 3 4]

यदि आप हाई पास्ट 0.10.1 (उदाहरण के लिए, गिट मास्टर) का संस्करण चला रहे हैं, तो एक अच्छा नया भी है
कीवर्ड तर्क वाक्यविन्यास:

=> (वैकल्पिक-आर्ग :कीवर्ड1 1
... :pos2 2
... :pos1 3
... :कीवर्ड2 4)
[०, २, १, ०]

अन्यथा, आप हमेशा उपयोग कर सकते हैं लागू करें. लेकिन क्या है? लागू करें?

क्या आप पासिंग इन से परिचित हैं? *तर्क और ** kwargs पायथन में?:

>>> तर्क = [1 2]
>>> क्वार्ग्स = {"कीवर्ड2": 3
... "कीवर्ड1": 4}
>>> वैकल्पिक_arg(*args, **kwargs)

हम इसके साथ पुनरुत्पादन कर सकते हैं लागू करें:

=> (सेटव तर्क [1 2])
=> (सेटव क्वार्ग्स {"कीवर्ड2" 3
... "कीवर्ड1" 4})
=> (वैकल्पिक-arg args kwargs लागू करें)
[०, २, १, ०]

एक शब्दकोश-शैली कीवर्ड तर्क निर्माण भी है जो इस तरह दिखता है:

(अन्य शैली को परिभाषित करें [&key {"key1" "val1" "key2" "val2"}]
[कुंजी1 कुंजी2])

यहाँ अंतर यह है कि चूँकि यह एक शब्दकोश है, आप किसी विशिष्ट शब्द पर भरोसा नहीं कर सकते
तर्कों को आदेश देना।

हाई भी सपोर्ट करता है *तर्क और ** kwargs. पायथन में:

def some_func(foo, bar, *args, **kwargs):
पीप्रिंट आयात करें
pprint.pprint((foo, bar, args, kwargs))

हाई समकक्ष:

(कुछ-फन को परिभाषित करें [फू बार एंड रेस्ट आर्ग्स एंड क्वार्ग्स क्वार्ग्स]
(आयात पीप्रिंट)
(pprint.pprint (, foo bar args kwargs)))

अंततः, निःसंदेह हमें कक्षाओं की आवश्यकता है! पायथन में, हमारे पास एक वर्ग हो सकता है जैसे:

वर्ग FooBar(ऑब्जेक्ट):
"" "
फिर भी एक और उदाहरण वर्ग
"" "
def __init__(स्वयं, x):
स्वयं.एक्स = एक्स

def get_x(स्वयं):
"" "
x की हमारी प्रति लौटाएँ
"" "
self.x वापस करें

हाई में:

(FooBar को डिफ़क्लास करें [ऑब्जेक्ट]
"फिर भी एक और उदाहरण वर्ग"
[[--इस में--
(एफएन [स्वयं x]
(setv self.xx)
; वर्तमान में --init-- की आवश्यकता है क्योंकि __init__ को किसी की आवश्यकता नहीं है
; उम्मीद है ये दूर हो जाएगा :)
कोई नहीं)]

[प्राप्त-x
(एफएन [स्वयं]
"x की हमारी प्रति लौटाएँ"
self.x)]])

आप कक्षा-स्तरीय विशेषताएँ भी कर सकते हैं। पायथन में:

वर्ग ग्राहक(मॉडल.मॉडल):
नाम = मॉडल। चारफिल्ड (max_length = २५५)
पता = मॉडल.TextField()
नोट्स = मॉडल.टेक्स्टफ़ील्ड()

हाई में:

(डिफ़क्लास ग्राहक [मॉडल.मॉडल]
[[नाम (मॉडल.चारफ़ील्ड: अधिकतम-लंबाई 255})]
[पता (मॉडल.टेक्स्टफ़ील्ड)]
[नोट्स (मॉडल.टेक्स्टफ़ील्ड)]])

Hy <-> अजगर इंटरॉप
Hy आयात करके, आप सीधे Python से Hy का उपयोग कर सकते हैं!

यदि आप निम्नलिखित को सहेजते हैं नमस्ते.हाय:

(नमस्कार नमस्कार [नाम] ("हाय से नमस्ते," नाम प्रिंट करें))

फिर आप मॉड्यूल आयात करने से पहले hy आयात करके इसे सीधे पायथन से उपयोग कर सकते हैं। में
अजगर:

आयात हाय
अभिवादन आयात करें

अभिनन्दन.नमस्कार("फू")

आप पायथन (या एक क्लास!) में भी एक फ़ंक्शन घोषित कर सकते हैं और इसे Hy में उपयोग कर सकते हैं!

यदि आप निम्नलिखित को सहेजते हैं शुभकामनाएँ.py पायथन में:

def नमस्कार(नाम):
प्रिंट करें ("हैलो, %s" % (नाम))

आप इसे हाई में उपयोग कर सकते हैं:

(आयात अभिवादन)
(.अभिवादन करें "फू")

कीवर्ड तर्कों का उपयोग करने के लिए, आप इसका उपयोग कर सकते हैं शुभकामनाएँ.py:

डीईएफ़ नमस्कार (नाम, शीर्षक = "सर"):
प्रिंट करें ("अभिवादन, %s %s" % (शीर्षक, नाम))

(आयात अभिवादन)
(.अभिवादन करें "फू")
(.अभिवादन करें "फू" "डार्थ")
(लागू करें (. नमस्कार नमस्कार) ["फू"] {"शीर्षक" "भगवान"})

जो आउटपुट देगा:

नमस्ते, सर फू

नमस्ते, डार्थ फू

नमस्ते, लॉर्ड फू

प्रोटिप्स!
Hy में "थ्रेडिंग मैक्रो" के रूप में जाना जाने वाला कुछ फीचर भी है, जो वास्तव में एक साफ-सुथरा फीचर है
क्लोजर का. "थ्रेडिंग मैक्रो" (इस रूप में लिखा गया है ->) का उपयोग गहरे घोंसले से बचने के लिए किया जाता है
भाव।

थ्रेडिंग मैक्रो प्रत्येक अभिव्यक्ति को अगली अभिव्यक्ति के पहले तर्क में सम्मिलित करता है
जगह.

आइए क्लासिक लें:

(लूप (प्रिंट (eval (पढ़ें))))

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

(-> (पढ़ें) (eval) (प्रिंट) (लूप))

अब, प्रयोग कर रहे हैं अजगर-श, हम दिखा सकते हैं कि थ्रेडिंग मैक्रो कैसे (पायथन-श के सेटअप के कारण)
पाइप की तरह इस्तेमाल किया जा सकता है:

=> (आयात [sh [cat grep wc]])
=> (-> (cat "/usr/share/dict/words") (grep "-E" "^hy") (wc "-l"))
210

जिसका, निस्संदेह, विस्तार होता है:

(wc (grep (cat "/usr/share/dict/words") "-E" "^hy") "-l")

बहुत अधिक पठनीय, नहीं? थ्रेडिंग मैक्रो का उपयोग करें!

HY स्टाइल गाइड

“आप जानते हैं, मंत्री महोदय, मैं कई मामलों में डंबलडोर से असहमत हूं...लेकिन आप इससे इनकार नहीं कर सकते
स्टाइल मिल गया..." - फिनीस निगेलस ब्लैक, सताना कुम्हार और la व्यवस्था of la अचंभा

हाई स्टाइल गाइड का इरादा हाईवे (हाँ, हाई समुदाय) के लिए बुनियादी नियमों का एक सेट होना है
मुहावरेदार Hy कोड लिखने के लिए हर चीज़ में Hy जोड़ने में गर्व महसूस करता है। हाई बहुत कुछ प्राप्त करता है
क्लोजर और कॉमन लिस्प से, हमेशा पायथन इंटरऑपेबिलिटी को बनाए रखते हुए।

प्रस्तावना
RSI ताओ of Hy
उम्मोन ने प्रधान भिक्षु से पूछा, "आप किस सूत्र पर व्याख्यान दे रहे हैं?"
"निर्वाण सूत्र।"
"निर्वाण सूत्र में चार गुण हैं, है ना?"
"यह है।"
उम्मोन ने प्याला उठाते हुए पूछा, "इसमें कितने गुण हैं?"
भिक्षु ने कहा, "बिल्कुल नहीं।"
"लेकिन प्राचीन लोगों ने कहा था कि ऐसा था, है ना?" उम्मोन ने कहा।
"उन्होंने जो कहा उसके बारे में आप क्या सोचते हैं?"
उम्मोन ने कप पर हाथ मारा और पूछा, "समझे?"
"नहीं," साधु ने कहा।
"फिर," उम्मोन ने कहा, "बेहतर होगा कि आप सूत्र पर अपना व्याख्यान जारी रखें।"
- (कोअन) मैक्रो

निम्नलिखित उन डिज़ाइन निर्णयों की एक संक्षिप्त सूची दिखाता है जिन्हें बनाने में लिया गया था
नमस्ते।

· लिस्प की तरह दिखें; इसके साथ डीटीआरटी (जैसे डैश अंडरस्कोर में बदल जाते हैं, ईयरमफ्स में बदल जाते हैं
सभी कैपिटल)।

· हम अभी भी पायथन हैं. अधिकांश इंटरनल्स 1:1 को पायथन इंटरनल्स में अनुवादित करते हैं।

· हर जगह यूनिकोड का प्रयोग करें.

· जब हम कर सकें तो Python 2 में ख़राब निर्णयों को ठीक करें (देखें)। सच्चा_विभाजन).

· जब संदेह हो तो पाइथॉन पर निर्भर रहें।

· यदि आप अभी भी अनिश्चित हैं, तो क्लोजर को टाल दें।

· यदि आप और भी अधिक अनिश्चित हैं, तो कॉमन लिस्प पर विचार करें।

· ध्यान रखें हम क्लोजर नहीं हैं। हम आम लिस्प नहीं हैं। हम होमोइकोनिक पायथन हैं, साथ में
अतिरिक्त बिट्स जो समझ में आते हैं।

ख़ाका & खरोज
· पीछे वाले स्थानों से बचें. वे चूसते हैं!

· इंडेंटेशन 2 स्थानों का होगा (कोई कठोर टैब नहीं), इंडेंटेशन के मिलान को छोड़कर
पिछली पंक्ति.

;; अच्छा (और पसंदीदा)
(defn fib [n]
(यदि (<= n 2)
n
(+ (फाइब (- एन 1)) (फाइब (- एन 2)))))

;; फिर भी ठीक है
(defn fib [n]
(यदि (<= n 2) n (+ (फाइब (- n 1)) (फाइब (- n 2)))))

;; फिर भी ठीक है
(defn fib [n]
(यदि (<= n 2)
n
(+ (फाइब (- एन 1)) (फाइब (- एन 2)))))

;; बेहद हास्यास्पद
(defn fib [n]
(यदि (<= n 2)
एन ;; हां, मुझे बेतरतीब ढंग से स्पेस कुंजी दबाना पसंद है
(+ (फाइब (- एन 1)) (फाइब (- एन 2)))))

· कोष्ठक अवश्य होना चाहिए कभी नहीँ अपनी ही लाइन पर अकेले, उदास और अकेले रह जाएंगे।

;; अच्छा (और पसंदीदा)
(defn fib [n]
(यदि (<= n 2)
n
(+ (फाइब (- एन 1)) (फाइब (- एन 2)))))

;; बेहद हास्यास्पद
(defn fib [n]
(यदि (<= n 2)
n
(+ (फाइब (- एन 1)) (फाइब (- एन 2)))
)
) ; गाह, इसे आग से जला दो

· लंबवत रूप से संरेखित करें चलो ब्लॉक।

(चलिए [[फू (बार)]
[क्वक्स (बाज़)]]
(फू क्वक्स))

· इनलाइन टिप्पणियाँ कोड के अंत से दो स्थानों पर होंगी; उनके पास हमेशा एक होना चाहिए
टिप्पणी चरित्र और टिप्पणी की शुरुआत के बीच का स्थान। साथ ही, ऐसा न करने का प्रयास करें
स्पष्ट टिप्पणी करें.

;; अच्छा
(setv ind (dec x)) ; अनुक्रमण 0 से प्रारंभ होता है

;; शैली के अनुरूप लेकिन केवल स्पष्ट बताता है
(setv ind (dec x)) ; सूचकांक को x-1 पर सेट करता है

;; खराब
(setv ind (dec x)); मनोरंजन के लिए शब्द टाइप करना

कोडन अंदाज
· एक परंपरा के रूप में, उपयोग न करने का प्रयास करें डीईएफ़ वैश्विक चर के अलावा किसी भी चीज़ के लिए; उपयोग setv
अंदर के कार्य, लूप आदि।

;; अच्छा (और पसंदीदा)
(डीईएफ़ *सीमा* 400000)

(फाइब्स को परिभाषित करें [एबी]
(जबकि सच है
(उपज ए)
(सेटव (, एबी) (, बी (+ एबी)))))

;; ख़राब (और पसंदीदा नहीं)
(फाइब्स को परिभाषित करें [एबी]
(जबकि सच है
(उपज ए)
(def (, ab) (, b (+ ab)))))

· जहां वेक्टर सिंटैक्स का इरादा है वहां एस-एक्सप्रेशन सिंटैक्स का उपयोग न करें। उदाहरण के लिए, तथ्य
इन दो उदाहरणों में से पहला काम सिर्फ इसलिए करता है क्योंकि कंपाइलर ज़्यादा नहीं है
कठोर। वास्तव में, इस तरह की जगहों में सही वाक्यविन्यास बाद वाला है।

;; बुरा (और बुरा)
(defn foo (x) (प्रिंट x))
(फू 1)

;; अच्छा (और पसंदीदा)
(defn foo [x] (प्रिंट x))
(फू 1)

· गहरे नेस्टेड का सामना करते समय थ्रेडिंग मैक्रो या थ्रेडिंग टेल मैक्रोज़ का उपयोग करें
एस-अभिव्यक्ति. हालाँकि, उनका उपयोग करते समय विवेकपूर्ण रहें। स्पष्टता और स्पष्टता होने पर इनका प्रयोग अवश्य करें
पठनीयता में सुधार होता है; जटिल, समझने में कठिन अभिव्यक्तियाँ न बनाएँ।

;; पसंदीदा
(डीईएफ़ *नाम*
([f के साथ ("names.txt" खोलें)]
(-> (.पढ़ें f) (.strip) (.replace "\"" "") (.split ",") (क्रमबद्ध))))

;; इतना अच्छा नहीं
(डीईएफ़ *नाम*
([f के साथ ("names.txt" खोलें)]
(क्रमबद्ध (.स्प्लिट "," (.रिप्लेस "\"" "" (.स्ट्रिप (.रीड एफ)))))))

;; शायद एक अच्छा विचार नहीं है
(वर्ग को परिभाषित करें? [x]
(->> 2 (पाउ (int (sqrt x))) (= x)))

· क्लोजर-शैली डॉट नोटेशन को ऑब्जेक्ट की विधि की सीधी कॉल की तुलना में प्राथमिकता दी जाती है,
हालाँकि दोनों का समर्थन जारी रहेगा।

;; अच्छा
([एफडी के साथ (खुला)/ Etc / पासवर्ड")]
(प्रिंट (.readlines fd)))

;; इतना अच्छा नहीं
([एफडी के साथ (खुला)/ Etc / पासवर्ड")]
(प्रिंट (fd.readlines)))

निष्कर्ष
"फैशन फीका पड़ जाता है, स्टाइल शाश्वत है" -यवेस सेंट लॉरेंट

यह मार्गदर्शिका सामुदायिक दिशानिर्देशों का एक सेट मात्र है, और जाहिर है, सामुदायिक दिशानिर्देश भी ऐसा ही करते हैं
सक्रिय समुदाय के बिना इसका कोई मतलब नहीं है। योगदान का स्वागत है. #hyin पर हमसे जुड़ें
फ्रीनोड, इसके बारे में ब्लॉग करें, इसके बारे में ट्वीट करें और सबसे महत्वपूर्ण बात, हाई के साथ आनंद लें।

धन्यवाद
· यह मार्गदर्शिका काफी हद तक प्रेरित है @पॉल्टैग का ब्लॉग पोस्ट Hy उत्तरजीविता मार्गदर्शिका

· Clojure अंदाज मार्गदर्शिका

प्रलेखन सूचकांक

सामग्री:

आदेश लाइन इंटरफेस
hy
आदेश लाइन ऑप्शंस
-c
में Hy कोड निष्पादित करें आदेश.

$ hy -c "(प्रिंट (+ 2 2))"
4

-i
में Hy कोड निष्पादित करें आदेश, फिर आरईपीएल में रहें।

-m
में Hy कोड निष्पादित करें मॉड्यूलसहित, defmain अगर परिभाषित किया गया है।

RSI -m फ़्लैग विकल्प सूची को समाप्त कर देता है ताकि उसके बाद के सभी तर्क समाप्त हो जाएँ मॉड्यूल नाम
में मॉड्यूल को पास कर दिया जाता है sys.argv.

संस्करण 0.10.2 में नया।

--जासूस निष्पादित करने से पहले समतुल्य पायथन कोड प्रिंट करें। उदाहरण के लिए:

=> (defn salutationsnm [नाम] (प्रिंट (+ "हाय " नाम "!")))
डीईएफ़ अभिवादनएनएम(नाम):
रिटर्न प्रिंट(((u'Hy ' + नाम) + u'!'))
=> (प्रणाम एनएम "आपका नाम")
नमस्कार एनएम(यू'आपका नाम')
नमस्ते आपका नाम!
=>

संस्करण 0.9.11 में नया।

--शो-ट्रेसबैक
हाई अपवादों के लिए विस्तारित ट्रेसबैक प्रिंट करें।

संस्करण 0.9.12 में नया।

-v हाई वर्जन नंबर प्रिंट करें और बाहर निकलें।

hyc
आदेश लाइन ऑप्शंस
फ़ाइल[, फ़ाइलएन]
हाई कोड को पायथन बाइटकोड में संकलित करें। उदाहरण के लिए, निम्नलिखित कोड को इस रूप में सहेजें
hyname.hy:

(defn hy-hy [नाम]
(प्रिंट करें (+ "हाय" नाम "!")))

(हाय-हाय "अफ़्रोमन")

फिर भागो:

$ hyc hyname.hy
$ पायथन hyname.pyc
हाय अफ्रोमैन!

hy2py
संस्करण 0.10.1 में नया।

आदेश लाइन ऑप्शंस
-s

--स्रोत के साथ
पार्स की गई स्रोत संरचना दिखाएँ.

-a

--साथ-अस्त
उत्पन्न एएसटी दिखाएँ.

-एनपीई

--बिना-अजगर के
एएसटी से उत्पन्न पायथन कोड न दिखाएं।

Hy ( भाषा: हिन्दी)
चेतावनी:
यह अधूरा है; कृपया दस्तावेज़ीकरण प्रयास में योगदान देने पर विचार करें।

सिद्धांत of Hy
बाकी सभी चीज़ों के अलावा, Hy, Python के साथ दोनों दिशाओं में 100% अनुकूलता बनाए रखता है
अपने आप। सभी हाई कोड कुछ सरल नियमों का पालन करते हैं। इसे याद रखें, क्योंकि यह अंदर आने वाला है
काम।

ये नियम यह सुनिश्चित करने में मदद करते हैं कि हाई कोड दोनों भाषाओं में मुहावरेदार और इंटरफ़ेस योग्य है।

· ईयरमफ्स में मौजूद प्रतीकों को उस स्ट्रिंग के बड़े संस्करण में अनुवादित किया जाएगा। के लिए
उदाहरण, foo हो जाएगा FOO.

· UTF-8 इकाइयों का उपयोग करके एन्कोड किया जाएगा पनीकोड और इसके साथ उपसर्ग लगा हुआ है हाय_। उदाहरण के लिए, ⚘
हो जाएगा hy_w7h, ♥ हो जाएगा hy_g6h, तथा मैं♥यू हो जाएगा hy_iu_t0x.

· जिन प्रतीकों में डैश हैं उन्हें अंडरस्कोर से बदल दिया जाएगा। उदाहरण के लिए,
प्रस्तुत करना-टेम्पलेट हो जाएगा रेंडर_टैम्पलेट. इसका मतलब है कि डैश वाले प्रतीक होंगे
उनके अंडरस्कोर समकक्षों को छाया दें, और इसके विपरीत।

निर्मित इन्स
Hy में कई विशेष फॉर्म हैं जिनका उपयोग सही पायथन एएसटी उत्पन्न करने में मदद के लिए किया जाता है।
निम्नलिखित "विशेष" रूप हैं, जिनमें ऐसा व्यवहार हो सकता है जो थोड़ा अप्रत्याशित हो
कुछ स्थितियाँ.

.
संस्करण 0.10.0 में नया।

. ऑब्जेक्ट पर विशेषता पहुंच निष्पादित करने के लिए उपयोग किया जाता है। यह त्वरित अनुमति देने के लिए एक छोटे डीएसएल का उपयोग करता है
नेस्टेड डेटा संरचना में विशेषताओं और वस्तुओं तक पहुंच।

उदाहरण के लिए:

(. फू बार बाज़ [(+ 1 2)] फ्रोब)

नीचे संकलित करता है:

foo.bar.baz[1 + 2].फ्रोब

. अपना पहला तर्क संकलित करता है (उदाहरण में, foo) उस वस्तु के रूप में जिस पर करना है
विशेषता विचलन. यह पहुंच के लिए विशेषताओं के रूप में नंगे प्रतीकों का उपयोग करता है (उदाहरण में, बार,
आधार, फ्रॉब), और सूचियों की सामग्री संकलित करता है (उदाहरण में, [(+ 1 2)]) इंडेक्सेशन के लिए।
अन्य तर्क संकलन त्रुटि उत्पन्न करते हैं।

अज्ञात विशेषताओं तक पहुंच एक फेंकता है विशेषतात्रुटि. अज्ञात कुंजियों तक पहुंच एक फेंकता है
अनुक्रमणिका (सूचियों और टुपल्स पर) या ए कुंजी त्रुटि (शब्दकोशों पर)।

->
-> (या सूत्रण मैक्रो) का उपयोग भावों के घोंसले से बचने के लिए किया जाता है। थ्रेडिंग मैक्रो
प्रत्येक अभिव्यक्ति को अगली अभिव्यक्ति के पहले तर्क स्थान में सम्मिलित करता है। निम्नलिखित
कोड इसे प्रदर्शित करता है:

=> (डिफ़न आउटपुट [एबी] (प्रिंट एबी))
=> (-> (+4 6) (आउटपुट 5))
10 5

- >>
- >> (या सूत्रण पूंछ मैक्रो) के समान है सूत्रण मैक्रो, लेकिन इसके बजाय
प्रत्येक अभिव्यक्ति को अगली अभिव्यक्ति के पहले तर्क में सम्मिलित करते हुए, यह इसे इस प्रकार जोड़ता है
अंतिम तर्क. निम्नलिखित कोड इसे प्रदर्शित करता है:

=> (डिफ़न आउटपुट [एबी] (प्रिंट एबी))
=> (->> (+4 6) (आउटपुट 5))
5 10

लागू करें
लागू करें तर्कों की एक वैकल्पिक सूची और क्वार्ग्स के एक वैकल्पिक शब्दकोश को लागू करने के लिए उपयोग किया जाता है
एक समारोह के लिए.

उपयोग: (आवेदन करना fn-नाम [तर्क] [क्वार्ग्स])

उदाहरण:

(ठंडक को परिभाषित करें []
"हाय वहाँ")

(थंक लागू करें)
;=> "हाय वहाँ"

(कुल खरीद को परिभाषित करें [मूल्य राशि और वैकल्पिक [शुल्क 1.05] [वैट 1.1]]
(*मूल्य राशि शुल्क वैट))

(कुल खरीद लागू करें [10 15])
;=> 173.25

(कुल खरीद लागू करें [10 15] {"वैट" 1.05})
;=> 165.375

(कुल खरीद लागू करें [] {"कीमत" 10 "राशि" 15 "वैट" 1.05})
;=> 165.375

और
और तार्किक अभिव्यक्तियों में प्रयोग किया जाता है। इसमें कम से कम दो पैरामीटर लगते हैं. यदि सभी पैरामीटर
का मूल्यांकन करें यह सच है, अंतिम पैरामीटर लौटा दिया गया है। किसी अन्य मामले में, पहला गलत मान
लौटा दी जाएगी। उदाहरण उपयोग:

=> (और सत्य असत्य)
झूठा

=> (और सच सच)
यह सच है

=> (और सत्य 1)
1

=> (और सत्य [] असत्य सत्य)
[]

नोट:
और पहला गलत होते ही शॉर्ट-सर्किट हो जाता है और मापदंडों का मूल्यांकन बंद हो जाता है
सामना करना पड़ा।

=> (और गलत ("हैलो" प्रिंट करें))
झूठा

जोर
जोर प्रोग्राम चलने के दौरान स्थितियों को सत्यापित करने के लिए उपयोग किया जाता है। यदि शर्त नहीं है
मिले, ए अभिकथनत्रुटि उठाया है। जोर एक या दो पैरामीटर ले सकते हैं. पहला
पैरामीटर जाँचने की शर्त है, और इसका मूल्यांकन इनमें से किसी एक पर किया जाना चाहिए यह सच है or झूठा।
दूसरा पैरामीटर, वैकल्पिक, दावे के लिए एक लेबल है, और वह स्ट्रिंग है जो होगी
के साथ बड़ा हुआ अभिकथनत्रुटि। उदाहरण के लिए:

(जोर दें (= परिवर्तनीय अपेक्षित-मान))

(गलत दावा करें)
; अभिकथनत्रुटि

(जोर दें (= 1 2) "एक दो के बराबर होना चाहिए")
; अभिकथनत्रुटि: एक दो के बराबर होना चाहिए

एसोसिएटेड
एसोसिएटेड किसी कुंजी को किसी शब्दकोश में किसी मान के साथ जोड़ने या किसी सूची का सूचकांक सेट करने के लिए उपयोग किया जाता है
एक मूल्य के लिए. इसमें कम से कम तीन पैरामीटर लगते हैं: तिथि संरचना संशोधित किया जाना है, ए कुंजी
or अनुक्रमणिका, और एक मूल्य. यदि तीन से अधिक पैरामीटर का उपयोग किया जाता है, तो यह जोड़े में संबद्ध होगा।

उपयोग के उदाहरण:

=>(चलो [[संग्रह {}]]
... (सहयोगी संग्रह "डॉग" "बार्क")
... (मुद्रण संग्रह))
{यू'डॉग': यू'बार्क'}

=>(चलो [[संग्रह {}]]
... (सहयोगी संग्रह "कुत्ता" "छाल" "बिल्ली" "म्याऊ")
... (मुद्रण संग्रह))
{यू'बिल्ली': यू'म्याऊं', यू'डॉग': यू'बार्क'}

=>(चलो [[संग्रह [1 2 3 4]]]
... (सहयोगी संग्रह 2 कोई नहीं)
... (मुद्रण संग्रह))
[1, 2, कोई नहीं, 4]

नोट:
एसोसिएटेड डेटास्ट्रक्चर को यथास्थान संशोधित करता है और वापस लौटाता है कोई नहीं.

तोड़ना
तोड़ना लूप से बाहर निकलने के लिए उपयोग किया जाता है। यह लूप को तुरंत समाप्त कर देता है। निम्नलिखित
उदाहरण में अनंत है जब लूप जो उपयोगकर्ता के प्रवेश करते ही समाप्त हो जाता है k.

(जबकि सत्य (यदि (= "k" (कच्चा-इनपुट "?"))
(तोड़ना)
("पुनः प्रयास करें" प्रिंट करें)))

cond
cond नेस्टेड बनाने के लिए उपयोग किया जा सकता है if बयान. निम्नलिखित उदाहरण दिखाता है
मैक्रो और उसके विस्तार के बीच संबंध:

(शर्त [स्थिति-1 परिणाम-1]
[स्थिति-2 परिणाम-2])

(यदि शर्त-1 परिणाम-1
(यदि शर्त-2 परिणाम-2))

जैसा कि नीचे दिखाया गया है, केवल पहला मिलान परिणाम ब्लॉक निष्पादित किया गया है।

=> (चेक-वैल्यू को परिभाषित करें [मूल्य]
... (शर्त [(< मान 5) (प्रिंट "मान 5 से छोटा है")]
... [(= मान 5) (प्रिंट "मान 5 के बराबर है")]
... [(> मान 5) (प्रिंट "मान 5 से अधिक है")]
... [सच (प्रिंट "मूल्य कुछ ऐसा है जो यह नहीं होना चाहिए")]))

=> (चेक-वैल्यू 6)
मान 5 से अधिक है

जारी रखने के
जारी रखने के लूप की शुरुआत में निष्पादन लौटाता है। निम्नलिखित उदाहरण में,
(दुष्प्रभाव1) प्रत्येक पुनरावृत्ति के लिए कहा जाता है। (दुष्प्रभाव2)हालाँकि, केवल बुलाया जाता है
सूची में प्रत्येक अन्य मान.

;; यह मानते हुए कि (साइड-इफेक्ट1) और (साइड-इफेक्ट2) फ़ंक्शन हैं और
;; संग्रह संख्यात्मक मानों की एक सूची है

([x संग्रह के लिए]
(का
(दुष्प्रभाव1 x)
(यदि (% x 2)
(जारी रखना))
(दुष्प्रभाव2 x)))

dict-comp
dict-comp शब्दकोश बनाने के लिए उपयोग किया जाता है। इसमें तीन या चार पैरामीटर लगते हैं। पहला
दो पैरामीटर रिटर्न वैल्यू (की-वैल्यू पेयर) को नियंत्रित करने के लिए हैं जबकि तीसरा है
अनुक्रम से वस्तुओं का चयन करने के लिए उपयोग किया जाता है। चौथे और वैकल्पिक पैरामीटर का उपयोग किया जा सकता है
सशर्त अभिव्यक्ति के आधार पर अनुक्रम में कुछ आइटम फ़िल्टर करें।

=> (dict-comp x (* x 2) [x (श्रेणी 10)] (विषम? x))
{1:2, 3:6, 9:18, 5:10, 7:14}

do / prog
do और prog उनके प्रत्येक तर्क का मूल्यांकन करने और अंतिम तर्क वापस करने के लिए उपयोग किया जाता है। वापस करना
अंतिम तर्क के अलावा अन्य सभी से मान हटा दिए जाते हैं। इसका उपयोग इसमें किया जा सकता है लैम्ब्डा or
सूची-कॉम्प अधिक जटिल तर्क निष्पादित करने के लिए जैसा कि निम्नलिखित उदाहरणों में से एक में दिखाया गया है।

कुछ उदाहरण उपयोग:

=> (यदि सत्य है
... (करें (प्रिंट करें "साइड इफेक्ट रॉक!")
... (प्रिंट "हाँ, वास्तव में!")))
दुष्प्रभाव रॉक!
हाँ सच में!

;; यह मानते हुए कि (साइड-इफ़ेक्ट) एक फ़ंक्शन है जिसे हम प्रत्येक के लिए कॉल करना चाहते हैं
;; और सूची में प्रत्येक मूल्य, लेकिन जिसके रिटर्न मूल्य की हमें परवाह नहीं है
=> (सूची-कॉम्प (करें (दुष्प्रभाव x)
... (यदि (< x 5) (* 2 x)
... (*4 x)))
... (x (रेंज 10)))
[१३, १ ९, २५, २ ९, ३१, ३ 0, ४३, ४ ९, ५३, ५५]

do 1 से n तक, किसी भी संख्या में तर्क स्वीकार कर सकते हैं।

डीईएफ़ / setv
डीईएफ़ और setv किसी मान, वस्तु या फ़ंक्शन को किसी प्रतीक से बांधने के लिए उपयोग किया जाता है। उदाहरण के लिए:

=> (परिभाषा नाम ["ऐलिस" "बॉब" "चार्ली"])
=> (नाम प्रिंट करें)
[यू'ऐलिस', यू'बॉब', यू'चार्ली']

=> (सेटव काउंटर (एफएन [संग्रह आइटम] (.गिनती संग्रह आइटम)))
=> (काउंटर [1 2 3 4 5 2 3] 2)
2

defclass
नई कक्षाओं की घोषणा की गई है defclass. इसमें दो वैकल्पिक पैरामीटर हो सकते हैं: एक वेक्टर
एक संभावित सुपर क्लास और नए की विशेषताओं वाले एक अन्य वेक्टर को परिभाषित करना
दो आइटम वैक्टर के रूप में वर्ग।

(डिफ़क्लास क्लास-नाम [सुपर-क्लास-1 सुपर-क्लास-2]
[[मान बताइए]])

मान और फ़ंक्शंस दोनों को नए वर्ग पर बाध्य किया जा सकता है जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है:

=> (डिफक्लास कैट []
... [[उम्र कोई नहीं]
... [रंग "सफ़ेद"]
... [बोलें (एफएन [स्वयं] (प्रिंट "म्याऊ"))]])

=> (डीईएफ़ स्पॉट (कैट))
=> (सेटव स्पॉट.कलर "ब्लैक")
'काला'
=> (.स्पिक स्पॉट)
मियांउ

रक्षा / defun
रक्षा और defun मैक्रोज़ का उपयोग फ़ंक्शंस को परिभाषित करने के लिए किया जाता है। वे तीन पैरामीटर लेते हैं: द नाम
परिभाषित करने के लिए फ़ंक्शन का, एक वेक्टर पैरामीटर, और परिवर्तन समारोह का:

(परिभाषित नाम [पैरामीटर] बॉडी)

पैरामीटर्स के सामने निम्नलिखित कीवर्ड हो सकते हैं:

&वैकल्पिक
पैरामीटर वैकल्पिक है. पैरामीटर को दो आइटम सूची के रूप में दिया जा सकता है, जहां
पहला तत्व पैरामीटर नाम है और दूसरा डिफ़ॉल्ट मान है। पैरामीटर
एकल आइटम के रूप में भी दिया जा सकता है, ऐसी स्थिति में डिफ़ॉल्ट मान है कोई नहीं.

=> (कुल-मूल्य को परिभाषित करें [मूल्य और वैकल्पिक [मूल्य-वर्धित-कर 10]]
... (+ (/ (* मूल्य मूल्य-वर्धित कर) 100) मूल्य))

=> (कुल-मान 100)
110.0

=> (कुल-मान 100 1)
101.0

&चाबी

&क्वार्ग्स
पैरामीटर में 0 या अधिक कीवर्ड तर्क होंगे।

निम्नलिखित कोड उदाहरण एक फ़ंक्शन को परिभाषित करते हैं जो सभी कीवर्ड प्रिंट करेगा
तर्क और उनके मूल्य।

=> (प्रिंट-पैरामीटर को परिभाषित करें [&kwargs kwargs]
... (के लिए [(, केवी) (.आइटम क्वार्ग्स)] (प्रिंट केवी)))

=> (प्रिंट-पैरामीटर लागू करें [] {"पैरामीटर-1" 1 "पैरामीटर-2" 2})
पैरामीटर-2 2
पैरामीटर-1 1

&आराम पैरामीटर में 0 या अधिक स्थितीय तर्क होंगे। कोई अन्य स्थिति नहीं
इसके बाद तर्क निर्दिष्ट किए जा सकते हैं।

निम्नलिखित कोड उदाहरण एक फ़ंक्शन को परिभाषित करता है जिसे 0 से n संख्यात्मक दिया जा सकता है
पैरामीटर. इसके बाद यह प्रत्येक विषम संख्या का योग करता है और प्रत्येक सम संख्या को घटाता है।

=> (ज़िग-ज़ैग-सम को परिभाषित करें [&बाकी संख्या]
(मान लीजिए [[विषम-संख्याएँ (सूची-कॉम्प x [x संख्याएँ] (विषम? x))]
[सम-संख्याएँ (सूची-कॉम्प x [x संख्याएँ] (सम? x))]]
(- (विषम संख्याओं का योग) (सम संख्याओं का योग))))

=> (ज़िग-ज़ैग-योग)
0
=> (ज़िग-ज़ैग-सम 3 9 4)
8
=> (ज़िग-ज़ैग-योग 1 2 3 4 5 6)
-3

defn-उपनाम / डिफ्यून-उपनाम
संस्करण 0.10.0 में नया।

RSI defn-उपनाम और डिफ्यून-उपनाम मैक्रोज़ बहुत पसंद हैं रक्षा, उस भेद के साथ
किसी फ़ंक्शन को एकल नाम से परिभाषित करने के बजाय, ये उपनाम भी परिभाषित कर सकते हैं। अन्य
पहले पैरामीटर के रूप में फ़ंक्शन नामों के लिए प्रतीकों की सूची लेने की तुलना में, defn-उपनाम और
डिफ्यून-उपनाम से भिन्न नहीं हैं रक्षा और defun.

=> (defn-उपनाम [मुख्य-नाम उपनाम] []
... (प्रिंट "हैलो!"))
=> (मुख्य-नाम)
"नमस्ते!"
=> (उपनाम)
"नमस्ते!"

defmain
संस्करण 0.10.1 में नया।

RSI defmain मैक्रो एक मुख्य फ़ंक्शन को परिभाषित करता है जिसे तुरंत कॉल किया जाता है sys.argv as
तर्क यदि और केवल यदि यह फ़ाइल एक स्क्रिप्ट के रूप में निष्पादित की जा रही है। दूसरे शब्दों में, यह:

(defmain [&rest args]
(तर्कों के साथ कुछ करें))

के बराबर है:

डीईएफ़ मुख्य(*आर्ग्स):
do_something_with(तर्क)
वापसी 0

अगर __name__ == "__main__":
आयात sys
रेटवल = मुख्य(*sys.arg)

यदि isinstance(retval, int):
sys.exit(पुनर्प्राप्ति)

ध्यान दें कि जैसा कि आप ऊपर देख सकते हैं, यदि आप इस फ़ंक्शन से एक पूर्णांक लौटाते हैं, तो यह होगा
आपकी स्क्रिप्ट के लिए निकास स्थिति के रूप में उपयोग किया जाता है। (पायथन डिफ़ॉल्ट रूप से स्थिति 0 से बाहर निकल जाता है अन्यथा,
जिसका मतलब है कि सब कुछ ठीक है!)

(तब से (sys.exit 0) गैर-पूर्णांक रिटर्न के मामले में स्पष्ट रूप से नहीं चलाया जाता है
defmain, यह लगाना एक अच्छा विचार है (डिफ़मेन) आपकी फ़ाइल में कोड के अंतिम भाग के रूप में।)

डिफमैक्रो
डिफमैक्रो मैक्रोज़ को परिभाषित करने के लिए उपयोग किया जाता है। सामान्य प्रारूप है (डेफ़मैक्रो नाम [पैरामीटर]
एक्सपीआर).

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

=> (डेफ़मैक्रो इन्फिक्स [कोड]
... (अर्ध उद्धरण (
... (उद्धरण न हटाएं (कोड 1 प्राप्त करें))
... (उद्धरण न हटाएं (कोड 0 प्राप्त करें))
... (अनउद्धरण (कोड 2 प्राप्त करें)))))

=> (इन्फिक्स (1 + 1))
2

defmacro-उपनाम
defmacro-उपनाम मैक्रोज़ को एकाधिक नामों (उपनाम) के साथ परिभाषित करने के लिए उपयोग किया जाता है। सामान्य प्रारूप
is (डेफ़मैक्रो-एलियास [नाम] [पैरामीटर] एक्सपीआर). यह एक ही के साथ कई मैक्रोज़ बनाता है
नामों की निर्दिष्ट सूची के अंतर्गत पैरामीटर सूची और बॉडी।

निम्नलिखित उदाहरण दो मैक्रोज़ को परिभाषित करता है, जिनमें से दोनों उपयोगकर्ता को कोड लिखने की अनुमति देते हैं
इन्फिक्स संकेतन।

=> (डेफ़मैक्रो-एलियास [इन्फिक्स इन्फ़ी] [कोड]
... (अर्ध उद्धरण (
... (उद्धरण न हटाएं (कोड 1 प्राप्त करें))
... (उद्धरण न हटाएं (कोड 0 प्राप्त करें))
... (अनउद्धरण (कोड 2 प्राप्त करें)))))

=> (इन्फिक्स (1 + 1))
2
=> (इन्फी (1+1))
2

डेफ़मैक्रो/जी!
संस्करण 0.9.12 में नया।

डेफ़मैक्रो/जी! का एक विशेष संस्करण है डिफमैक्रो जिसका उपयोग स्वचालित रूप से उत्पन्न करने के लिए किया जाता है gensym
किसी भी प्रतीक के लिए जो शुरू होता है g!.

उदाहरण के लिए, जी!ए बन जाएगा (जेनसिम "ए").

देख यह भी:
अनुभाग का उपयोग-जेनसिम

रक्षा करनेवाला
संस्करण 0.9.12 में नया।

रक्षा करनेवाला एक रीडर मैक्रो को परिभाषित करता है, जो आपको सिंटैक्स को पुनर्गठित या संशोधित करने में सक्षम बनाता है।

=> (डिफ़्रेडर ^ [एक्सपीआर] (प्रिंट एक्सपीआर))
=> #^(1 2 3 4)
(०1०० १६ २५ ५०)
=> #^"हैलो"
"नमस्ते"

देख यह भी:
अनुभाग रीडर मैक्रोज़

डेल
संस्करण 0.9.12 में नया।

डेल किसी ऑब्जेक्ट को वर्तमान नेमस्पेस से हटा देता है।

=> (सेटव फू 42)
=> (डेल फू)
=> फू
ट्रेसबैक (सबसे हालिया कॉल अंतिम):
फ़ाइल " ", पंक्ति 1, में
NameError: नाम 'फू' परिभाषित नहीं है

डेल मैपिंग, सूचियों आदि से ऑब्जेक्ट को हटा भी सकता है।

=> (सेटव परीक्षण (सूची (श्रेणी 10)))
=> परीक्षण
[१३, १ ९, २५, २ ९, ३१, ३ 0, ४३, ४ ९, ५३, ५५]
=> (डेल (स्लाइस टेस्ट 2 4)) ;; 2 से 4 तक बहिष्कृत आइटम हटा दें
=> परीक्षण
[0, 1, 4, 5, 6, 7, 8, 9]
=> (सेटव डीआईसी {"फू" "बार"})
=> डिक
{"फू": "बार"}
=> (डेल (डिक "फू" प्राप्त करें))
=> डिक
{}

करने के लिए करते हैं
संस्करण 0.10.1 में नया।

करने के लिए करते हैं किसी ऑब्जेक्ट पर विधि कॉल के अनुक्रम को सरल बनाने के लिए उपयोग किया जाता है।

=> (डॉटो [] (.1 जोड़ें) (.2 जोड़ें) .रिवर्स)
[2 1]

=> (सेटव संग्रह [])
=> (.संग्रह 1 जोड़ें)
=> (.संग्रह 2 जोड़ें)
=> (.रिवर्स संग्रह)
=> संग्रह
[2 1]

विकसित करना
विकसित करना उद्धृत अभिव्यक्ति का मूल्यांकन करता है और मान लौटाता है।

=> (eval '(प्रिंट "हैलो वर्ल्ड"))
"नमस्ते दुनिया"

eval-and-compile
eval-कब-संकलन
प्रथम / कार
प्रथम और कार संग्रह के पहले तत्व तक पहुँचने के लिए मैक्रोज़ हैं:

=> (प्रथम (श्रेणी 10))
0

एसटी
एसटी किसी सूची या वेक्टर में प्रत्येक तत्व के लिए फ़ंक्शन को कॉल करने के लिए उपयोग किया जाता है। प्रत्येक के परिणाम
कॉल खारिज कर दी जाती है और एसटी अभिव्यक्ति लौटती है कोई नहीं बजाय। उदाहरण कोड पुनरावृत्त होता है
के ऊपर संग्रह और प्रत्येक के लिए तत्व in संग्रह कॉल करता है खराब असर के साथ कार्य करें
तत्व इसके तर्क के रूप में:

;; यह मानते हुए कि (साइड-इफेक्ट) एक ऐसा फ़ंक्शन है जो एकल पैरामीटर लेता है
([तत्व संग्रह] के लिए (दुष्प्रभाव तत्व))

;; for में एक वैकल्पिक else ब्लॉक हो सकता है
([तत्व संग्रह] के लिए (दुष्प्रभाव तत्व)
(अन्यथा (दुष्परिणाम-2)))

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

=> ([तत्व के लिए [1 2 3]] (यदि (<तत्व 3)
... (प्रिंट तत्व)
... (तोड़ना))
... (अन्यथा ("लूप समाप्त" प्रिंट करें)))
1
2

=> ([तत्व के लिए [1 2 3]] (यदि (<तत्व 4)
... (प्रिंट तत्व)
... (तोड़ना))
... (अन्यथा ("लूप समाप्त" प्रिंट करें)))
1
2
3
लूप ख़त्म

जीनएक्सपीआर
जीनएक्सपीआर जेनरेटर एक्सप्रेशन बनाने के लिए उपयोग किया जाता है। इसमें दो या तीन पैरामीटर लगते हैं।
पहला पैरामीटर रिटर्न वैल्यू को नियंत्रित करने वाली अभिव्यक्ति है, जबकि दूसरे का उपयोग किया जाता है
किसी सूची से आइटम का चयन करने के लिए. तीसरे और वैकल्पिक पैरामीटर का उपयोग फ़िल्टर करने के लिए किया जा सकता है
सूची में कुछ आइटम सशर्त अभिव्यक्ति पर आधारित हैं। जीनएक्सपीआर के समान है
सूची-कॉम्प, सिवाय इसके कि यह एक पुनरावर्तनीय लौटाता है जो मानों का एक-एक करके मूल्यांकन करता है
उनका तुरंत मूल्यांकन करना।

=> (डीईएफ़ संग्रह (रेंज 10))
=> (def फ़िल्टर किया गया (genexpr x [x संग्रह] (सम? x)))
=> (सूची फ़िल्टर की गई)
[0, 2, 4, 6, 8]

gensym
संस्करण 0.9.12 में नया।

gensym इसका उपयोग एक अद्वितीय प्रतीक उत्पन्न करने के लिए किया जाता है जो मैक्रोज़ को बिना लिखे लिखने की अनुमति देता है
आकस्मिक चर नाम टकराव.

=> (जेनसिम)
यू':जी_1235'

=> (जेनसिम "x")
यू':x_1236'

देख यह भी:
अनुभाग का उपयोग-जेनसिम

मिल
मिल सूचियों और शब्दकोशों में एकल तत्वों तक पहुँचने के लिए उपयोग किया जाता है। मिल दो पैरामीटर लेता है:
la तिथि संरचना और अनुक्रमणिका or कुंजी वस्तु का. इसके बाद यह संबंधित रिटर्न देगा
शब्दकोश या सूची से मूल्य. उदाहरण उपयोग:

=> (मान लीजिए [[जानवरों को {"कुत्ता" "भौंकना" "बिल्ली" "म्याऊ"}]
... [संख्याएं ["शून्य" "एक" "दो" "तीन"]]]
... (प्रिंट करें (जानवरों को "कुत्ता" प्राप्त करें))
... (प्रिंट करें (संख्या 2 प्राप्त करें)))
छाल
दो

नोट:
मिल यदि किसी गैर-मौजूदा कुंजी के लिए शब्दकोश से पूछताछ की जाती है तो एक KeyError उठाता है।

नोट:
मिल यदि किसी सूची या टुपल से किसी ऐसे सूचकांक के लिए पूछताछ की जाती है जो बाहर है तो एक IndexError उठाता है
सीमा

वैश्विक
वैश्विक किसी प्रतीक को वैश्विक के रूप में चिह्नित करने के लिए उपयोग किया जा सकता है। यह प्रोग्रामर को असाइन करने की अनुमति देता है
एक वैश्विक प्रतीक का मूल्य. वैश्विक प्रतीक को पढ़ने के लिए इसकी आवश्यकता नहीं होती है वैश्विक कीवर्ड --
केवल इसे असाइन करना ही काम करता है।

निम्नलिखित उदाहरण दिखाता है कि वैश्विक प्रतीक कैसा है a किसी फ़ंक्शन में एक मान निर्दिष्ट किया गया है और
बाद में इसे किसी अन्य फ़ंक्शन में मुद्रित किया जाता है। के बिना वैश्विक कीवर्ड, दूसरा फ़ंक्शन
एक फेंक दिया होगा नामत्रुटि.

(डिफेन सेट-ए [मान]
(वैश्विक ए)
(एक मान सेट करें))

(डिफेन प्रिंट-ए []
(ए प्रिंट करें))

(सेट-ए 5)
(प्रिंट-ए)

if / अगर नहीं
संस्करण 0.10.0 में नया: यदि नहीं

if निष्पादित किए जाने वाले कोड को सशर्त रूप से चुनने के लिए उपयोग किया जाता है। इसमें एक शर्त होनी चाहिए
ब्लॉक और यदि कंडीशन ब्लॉक का मूल्यांकन किया जाता है तो ब्लॉक को निष्पादित किया जाना है यह सच है. वैकल्पिक रूप से,
इसमें एक अंतिम ब्लॉक हो सकता है जिसे स्थिति के मूल्यांकन के मामले में निष्पादित किया जाता है
झूठा.

अगर नहीं समान है, लेकिन दूसरा ब्लॉक तब निष्पादित किया जाएगा जब स्थिति विफल हो जाएगी
परीक्षण सफल होने पर तीसरा और अंतिम ब्लॉक निष्पादित किया जाता है - विपरीत क्रम में if.

उदाहरण उपयोग:

(यदि (पैसा बचा है? खाता)
(प्रिंट करें "चलो खरीदारी करने चलें")
(प्रिंट करें "आओ चलें और काम करें"))

(यदि नहीं (पैसा बचा है? खाता)
(प्रिंट "आओ चलें और काम करें")
(प्रिंट करें "आओ खरीदारी करने चलें"))

अजगर की सत्यता का सम्मान किया जाता है। कोई नहीं, झूठा, किसी भी संख्यात्मक प्रकार का शून्य, एक खाली अनुक्रम,
और एक खाली शब्दकोष माना जाता है झूठा; बाकी सब बातों पर विचार किया जाता है यह सच है.

तुतलाना-अगर / रेशा और तुतलाना-अगर-नहीं / जीवन-नहीं
संस्करण 0.10.0 में नया।

संस्करण 0.10.2 में नया: लिस्प-इफ-नॉट / लिफ-नॉट

उन लोगों के लिए जो अधिक लिस्पी पसंद करते हैं if खंड, हमारे पास है तुतलाना-अगरया, रेशा। इस केवल समझता है
कोई नहीं / शून्य झूठा होना! अन्य सभी "झूठे-ईश" पायथन मान सत्य माने जाते हैं।
इसके विपरीत, हमारे पास है तुतलाना-अगर-नहीं और जीवन-नहीं के समानांतर if और अगर नहीं जो उलट जाता है
तुलना।

=> (लिस्प-यदि सत्य है "सत्य" "गलत")
"सच"
=> (लिस्प-यदि गलत "सत्य" "गलत")
"सच"
=> (लिस्प-यदि 0 "सही" "गलत")
"सच"
=> (लिस्प-यदि शून्य "सही" "गलत")
"असत्य"
=> (लिस्प-यदि कोई नहीं "सही" "गलत")
"असत्य"
=> (लिस्प-अगर-नहीं शून्य "सही" "गलत")
"सच"
=> (लिस्प-अगर-नहीं कोई नहीं "सच्चा" "गलत")
"सच"
=> (तुतलाना-अगर-नहीं गलत "सच्चा" "गलत")
"असत्य"

; समतुल्य लेकिन छोटा
=> (यदि सत्य है "सत्य" "असत्य")
"सच"
=> (यदि कोई नहीं "सही" "गलत")
"असत्य"
=> (जीवन-नहीं कोई नहीं "सही" "गलत")
"सच"

आयात
आयात मॉड्यूल आयात करने के लिए उपयोग किया जाता है, जैसे पायथन में। इसके कई तरीके हैं आयात कर सकते हैं
इस्तेमाल किया गया।

;; इनमें से प्रत्येक मॉड्यूल को आयात करता है
;;
;; पायथन:
;; आयात sys
;; ओएस.पथ आयात करें
(आयात sys os.path)

;; एक मॉड्यूल से आयात करें
;;
;; पायथन: os.path से आयात मौजूद है, isdir, isfile
(आयात करें [os.path [isdir isfile मौजूद है]])

;; उपनाम के साथ आयात करें
;;
;; पायथन: सिस्टम को सिस्टेस्ट के रूप में आयात करें
(आयात [sys :as systest])

;; आप विभिन्न प्रकार के जितने चाहें उतने आयात सूचीबद्ध कर सकते हैं।
(आयात करें [tests.resources [kwtest function-with-a-dash]]
[os.path [isdir isfile मौजूद है]]
[sys :as systest])

;; सभी मॉड्यूल फ़ंक्शंस को वर्तमान नेमस्पेस में आयात करें
(आयात [sys [*]])

लैम्ब्डा / fn
लैम्ब्डा और fn किसी अज्ञात फ़ंक्शन को परिभाषित करने के लिए उपयोग किया जा सकता है। पैरामीटर समान हैं
रक्षा: पहला पैरामीटर पैरामीटर्स का वेक्टर है और बाकी पैरामीटर्स का मुख्य भाग है
समारोह. लैम्ब्डा एक नया फ़ंक्शन लौटाता है। निम्नलिखित उदाहरण में, एक अनाम फ़ंक्शन
परिभाषित किया गया है और आउटपुट को फ़िल्टर करने के लिए किसी अन्य फ़ंक्शन को पास कर दिया गया है।

=> (लोगों को परिभाषित करें [{:नाम "ऐलिस":उम्र 20}
... {:नाम "बॉब" :उम्र 25}
... {:नाम "चार्ली" :उम्र 50}
... {:नाम "डेव" :उम्र 5}])

=> (प्रदर्शन-लोग को परिभाषित करें [लोग फ़िल्टर]
... ([व्यक्ति लोगों के लिए] (यदि (फ़िल्टर व्यक्ति) (प्रिंट (:नाम व्यक्ति)))))

=> (प्रदर्शन-लोग लोग (एफएन [व्यक्ति] (<(:आयु व्यक्ति) 25)))
ऐलिस
पंडुक

सामान्य फ़ंक्शन परिभाषाओं की तरह, यदि बॉडी का पहला तत्व एक स्ट्रिंग है, तो यह
डॉकस्ट्रिंग के रूप में कार्य करता है। यह क्लास विधियों को डॉकस्ट्रिंग्स देने के लिए उपयोगी है।

=> (सेटव टाइम्स-तीन
... (एफएन [x]
... "इनपुट को तीन से गुणा करता है और परिणाम देता है।"
... (* x 3)))

इसकी पुष्टि Python के बिल्ट-इन के माध्यम से की जा सकती है मदद समारोह:

=> (सहायता समय-तीन)
फ़ंक्शन टाइम्स_थ्री पर सहायता:

बार_तीन(x)
इनपुट को तीन से गुणा करता है और परिणाम देता है
(समाप्त)

पिछली बार
संस्करण 0.10.2 में नया।

पिछली बार संग्रह के अंतिम तत्व तक पहुँचने के लिए इसका उपयोग किया जा सकता है:

=> (अंतिम [2 4 6])
6

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

=> (मान लीजिए [[x 5]] (x प्रिंट करें)
... (मान लीजिए [[x 6]] (x प्रिंट करें))
... (प्रिंट एक्स))
5
6
5

RSI चलो मैक्रो दो पैरामीटर लेता है: एक वेक्टर परिभाषित करना चर और परिवर्तन जो मिलता है
मार डाला। चर एक वेक्टर है जहां प्रत्येक तत्व या तो एक एकल चर या एक वेक्टर है
एक परिवर्तनीय मान युग्म को परिभाषित करना। एकल चर के मामले में, इसे मान निर्दिष्ट किया गया है
कोई नहीं; अन्यथा, प्रदत्त मूल्य का उपयोग किया जाता है।

=> (मान लीजिए [x [y 5]] (xy प्रिंट करें))
कोई नहीं 5

सूची-कॉम्प
सूची-कॉम्प सूची समझ निष्पादित करता है। इसमें दो या तीन पैरामीटर लगते हैं। पहला
पैरामीटर रिटर्न वैल्यू को नियंत्रित करने वाली अभिव्यक्ति है, जबकि दूसरे का उपयोग किया जाता है
किसी सूची से आइटम चुनें. तीसरे और वैकल्पिक पैरामीटर का उपयोग कुछ को फ़िल्टर करने के लिए किया जा सकता है
सशर्त अभिव्यक्ति के आधार पर सूची में आइटमों की संख्या। कुछ उदाहरण:

=> (डीईएफ़ संग्रह (रेंज 10))
=> (सूची-कॉम्प x [x संग्रह])
[१३, १ ९, २५, २ ९, ३१, ३ 0, ४३, ४ ९, ५३, ५५]

=> (सूची-कॉम्प (* x 2) [x संग्रह])
[१३, १ ९, २५, २ ९, ३१, ३ 0, ४३, ४ ९, ५३, ५५]

=> (सूची-कॉम्प (* x 2) [x संग्रह] (< x 5))
[0, 2, 4, 6, 8]

नहीं
नहीं तार्किक अभिव्यक्तियों में प्रयोग किया जाता है। यह एकल पैरामीटर लेता है और उलटा रिटर्न देता है
सत्य मूल्य. अगर यह सच है एक पैरामीटर के रूप में दिया गया है, झूठा वापस कर दिया जाएगा, और इसके विपरीत।
उदाहरण उपयोग:

=> (सत्य नहीं)
झूठा

=> (झूठा नहीं)
यह सच है

=> (कोई नहीं)
यह सच है

or
or तार्किक अभिव्यक्तियों में प्रयोग किया जाता है। इसमें कम से कम दो पैरामीटर लगते हैं. यह वापस कर देगा
पहला गैर-गलत पैरामीटर. यदि ऐसा कोई मान मौजूद नहीं है, तो अंतिम पैरामीटर वापस कर दिया जाएगा।

=> (या सच्चा झूठ)
यह सच है

=> (और गलत गलत)
झूठा

=> (और असत्य 1 सत्य असत्य)
1

नोट:
or पहला वास्तविक मान आते ही शॉर्ट-सर्किट हो जाता है और मापदंडों का मूल्यांकन बंद हो जाता है
सामना करना पड़ा।

=> (या सत्य ("हैलो" प्रिंट करें))
यह सच है

छाप
छाप स्क्रीन पर आउटपुट के लिए उपयोग किया जाता है। उदाहरण उपयोग:

(प्रिंट "हैलो वर्ल्ड!")

नोट:
छाप हमेशा लौटता है कोई नहीं.

quasiquote
quasiquote आपको किसी प्रपत्र को उद्धृत करने की अनुमति देता है, लेकिन साथ ही भावों का चयनात्मक मूल्यांकन भी करता है।
ए के अंदर अभिव्यक्तियाँ quasiquote का उपयोग करके चयनात्मक मूल्यांकन किया जा सकता है गंदें शब्द बोलना (~).
मूल्यांकन प्रपत्र का उपयोग करके भी जोड़ा जा सकता है अउद्धरण-विभाजन (~@). Quasiquote भी हो सकता है
बैककोट का उपयोग करके लिखा गया (`) प्रतीक।

;; मान लीजिए `क्वक्स' मान के साथ एक चर है (बार बाज़)
`(फू ~क्वक्स)
; '(फू (बार बाज़)) के बराबर
`(फू ~@क्वक्स)
; '(फू बार बाज़) के बराबर

उद्धरण
उद्धरण पास किए गए फॉर्म को बिना मूल्यांकन किए लौटा देता है। उद्धरण वैकल्पिक रूप से हो सकता है
एपॉस्ट्रॉफ़ी का उपयोग करके लिखा गया (') प्रतीक।

=> (सेटव x '(प्रिंट "हैलो वर्ल्ड"))
; वेरिएबल x अभिव्यक्ति पर सेट है और मूल्यांकन नहीं किया गया है
=> एक्स
(यू'प्रिंट' यू'हैलो वर्ल्ड')
=> (eval x)
नमस्ते विश्व

की आवश्यकता होती है
की आवश्यकता होती है किसी दिए गए मॉड्यूल से मैक्रोज़ आयात करने के लिए उपयोग किया जाता है। इसमें कम से कम एक पैरामीटर लगता है
मॉड्यूल को निर्दिष्ट करना कि कौन से मैक्रोज़ आयात किए जाने चाहिए। एकाधिक मॉड्यूल आयात किए जा सकते हैं
एक के साथ की आवश्यकता होती है.

निम्न उदाहरण से मैक्रोज़ आयात किया जाएगा मॉड्यूल 1 और मॉड्यूल 2:

(मॉड्यूल-1 मॉड्यूल-2 की आवश्यकता है)

आराम / कमांडर
आराम और कमांडर पहले तत्व के बिना तर्क के रूप में पारित संग्रह को वापस लौटाएँ:

=> (बाकी (रेंज 10))
[०, १, २, ३, ४, ६, ७, ८, ९]

सेट-कॉम्प
सेट-कॉम्प सेट बनाने के लिए उपयोग किया जाता है। इसमें दो या तीन पैरामीटर लगते हैं। पहला पैरामीटर है
रिटर्न वैल्यू को नियंत्रित करने के लिए, जबकि दूसरे का उपयोग ए से आइटम का चयन करने के लिए किया जाता है
अनुक्रम। तीसरे और वैकल्पिक पैरामीटर का उपयोग कुछ वस्तुओं को फ़िल्टर करने के लिए किया जा सकता है
सशर्त अभिव्यक्ति पर आधारित अनुक्रम।

=> (सेटव डेटा [1 2 3 4 5 2 3 4 5 3 4 5])
=> (सेट-कॉम्प x [x डेटा] (विषम? x))
{1, 3, 5}

टुकड़ा
टुकड़ा इसका उपयोग किसी सूची का सबसेट लेने और उससे एक नई सूची बनाने के लिए किया जा सकता है। फार्म
स्लाइस करने के लिए सूची को निर्दिष्ट करने वाला कम से कम एक पैरामीटर लेता है। दो वैकल्पिक पैरामीटर हो सकते हैं
उपसमुच्चय की आरंभ और समाप्ति स्थिति देने के लिए उपयोग किया जाता है। यदि उनकी आपूर्ति नहीं की जाती है, तो
का डिफ़ॉल्ट मान कोई नहीं इसके स्थान पर उपयोग किया जाएगा. तीसरे वैकल्पिक पैरामीटर का उपयोग किया जाता है
तत्वों के बीच नियंत्रण कदम.

टुकड़ा अपने पायथन समकक्ष के समान नियमों का पालन करता है। नकारात्मक सूचकांकों की गणना की जाती है
सूची के अंत से प्रारंभ करें. कुछ उदाहरण उपयोग:

=> (डीईएफ़ संग्रह (रेंज 10))

=> (स्लाइस संग्रह)
[१३, १ ९, २५, २ ९, ३१, ३ 0, ४३, ४ ९, ५३, ५५]

=> (स्लाइस संग्रह 5)
[5, 6, 7, 8, 9]

=> (स्लाइस संग्रह 2 8)
[३, ४, ६, ५, 2, 3]

=> (स्लाइस संग्रह 2 8 2)
[2, 4, 6]

=> (स्लाइस संग्रह -4 -2)
[6, 7]

फेंकना / उठाना
RSI फेंकना or उठाना फॉर्म का उपयोग बढ़ाने के लिए किया जा सकता है अपवाद चलने के समय पर। उदाहरण उपयोग:

(फेंक)
; अंतिम अपवाद पुनः उठाएँ

(IOError फेंकें)
; एक IOError फेंकें

(फेंकें (IOError "फूबार"))
; एक IOError("foobar") फेंकें

फेंकना एक ही तर्क स्वीकार कर सकते हैं (ए अपवाद वर्ग या उदाहरण) या कोई तर्क नहीं
पिछले को फिर से बढ़ाएँ अपवाद.

कोशिश
RSI कोशिश फॉर्म का उपयोग शुरू करने के लिए किया जाता है कोशिश / पकड़ अवरोध पैदा करना। प्रपत्र का उपयोग इस प्रकार किया जाता है:

(प्रयत्न
(त्रुटि-प्रवण-फ़ंक्शन)
(पकड़ें [e ZeroDivisionError] ("डिवीजन बाय जीरो") प्रिंट करें)
(अन्यथा ("कोई त्रुटि नहीं" प्रिंट करें))
(अंत में ("सभी हो गया" प्रिंट करें)))

कोशिश कम से कम एक अवश्य होना चाहिए पकड़ ब्लॉक करें, और इसमें वैकल्पिक रूप से एक शामिल हो सकता है अन्य or आखिरकार
अवरोध पैदा करना। यदि निष्पादन के दौरान मिलान कैच ब्लॉक के साथ कोई त्रुटि उत्पन्न होती है
त्रुटि-प्रवण-कार्यकि, पकड़ ब्लॉक निष्पादित किया जाएगा. यदि कोई त्रुटि नहीं उठाई जाती है, तो अन्य
ब्लॉक निष्पादित है. आखिरकार चाहे कोई भी हो या नहीं, ब्लॉक को अंतिम रूप से निष्पादित किया जाएगा
त्रुटि उठाई गई.

जब तक
RSI जब तक मैक्रो एक लिखने का आशुलिपि है if कथन जो जाँचता है कि क्या दिया गया है
सशर्त है झूठा. निम्नलिखित इस मैक्रो का विस्तार दर्शाता है.

(जब तक कि सशर्त बयान न हो)

(यदि सशर्त
कोई नहीं
(बयान दें))

गंदें शब्द बोलना
अर्धउद्धृत रूप में, गंदें शब्द बोलना किसी प्रतीक के मूल्यांकन को बाध्य करता है। गंदें शब्द बोलना को उपनाम दिया गया है
टिल्ड (~) प्रतीक।

(डिफ़ाइन नाम "कडल्स")
(अर्ध उद्धरण (= नाम (नाम उद्धृत न करें)))
;=> (u'=' u'name' u'Cuddles')

`(=नाम ~नाम)
;=> (u'=' u'name' u'Cuddles')

अउद्धरण-विभाजन
अउद्धरण-विभाजन किसी प्रतीक के मूल्यांकन को अर्ध-उद्धृत रूप में बाध्य करना, बहुत कुछ इसी तरह
गंदें शब्द बोलना. अउद्धरण-विभाजन केवल तभी उपयोग किया जा सकता है जब प्रतीक को उद्धृत न किए जाने पर एक शामिल हो
पुनरावर्तनीय मान, क्योंकि यह "विभाजन" करता है जो कि अर्धउद्धृत रूप में पुनरावृत्त होता है। अउद्धरण-विभाजन is
को उपनाम दिया गया ~@ प्रतीक।

(डीईएफ़ अंक [1 2 3 4])
(क्वासिकोट (+ (अनउद्धरण-विभाजन अंक)))
;=> (यू'+' 1एल 2एल 3एल 4एल)

`(+ ~@अंक)
;=> (यू'+' 1एल 2एल 3एल 4एल)

कब
कब के समान है जब तक, सिवाय इसके कि यह तब परीक्षण करता है जब दी गई शर्त होती है यह सच है। यह नहीं
एक होना संभव है अन्य ए में ब्लॉक करें कब मैक्रो. निम्नलिखित का विस्तार दर्शाता है
मैक्रो।

(जब सशर्त बयान)

(यदि सशर्त (कथन करें))

जब
जब जब तक कोई शर्त पूरी होती है तब तक एक या अधिक ब्लॉक निष्पादित करने के लिए उपयोग किया जाता है। निम्नलिखित
उदाहरण आउटपुट होगा "हैलो वर्ल्ड!" स्क्रीन पर अनिश्चित काल तक:

(जबकि सत्य ("हैलो वर्ल्ड!" प्रिंट करें))

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

([[arg (expr)]] ब्लॉक के साथ)

([[(expr)]] ब्लॉक के साथ)

([[arg (expr)] [(expr)]] ब्लॉक के साथ)

निम्नलिखित उदाहरण खुल जाएगा NEWS फ़ाइल करें और उसकी सामग्री को स्क्रीन पर प्रिंट करें।
फ़ाइल संसाधित होने के बाद स्वचालित रूप से बंद हो जाती है।

([[f ("समाचार" खोलें)]] (प्रिंट (.read f)) के साथ)

सज्जाकार के साथ
सज्जाकार के साथ एक फ़ंक्शन को दूसरे के साथ लपेटने के लिए उपयोग किया जाता है। कार्य निष्पादित कर रहा है
सजावट को एक ही मान स्वीकार करना चाहिए: फ़ंक्शन सजाया जा रहा है, और एक नया लौटाना चाहिए
समारोह. सज्जाकार के साथ न्यूनतम दो पैरामीटर लेता है: कार्य निष्पादित करना
सजावट और समारोह को सजाया जा रहा है। एक से अधिक डेकोरेटर कार्य हो सकते हैं
लागू; उन्हें सबसे बाहरी से सबसे भीतरी तक, यानी क्रम में लागू किया जाएगा। पहला
डेकोरेटर सबसे बाहरी होगा, इत्यादि। तर्क-वितर्क करने वाले सज्जाकार न्यायप्रिय कहलाते हैं
एक फ़ंक्शन कॉल की तरह.

(साथ-डेकोरेटर डेकोरेटर-मज़ा
(कुछ फ़ंक्शन को परिभाषित करें [] ...)

(साथ-डेकोरेटर डेकोरेटर1 डेकोरेटर2...
(कुछ फ़ंक्शन को परिभाषित करें [] ...)

(साथ-डेकोरेटर (डेकोरेटर तर्क) ..
(कुछ फ़ंक्शन को परिभाषित करें [] ...)

निम्नलिखित उदाहरण में, इंक-डेकोरेटर समारोह को सजाने के लिए उपयोग किया जाता है इसके अलावा पंजीकरण शुल्क
फ़ंक्शन जो दो पैरामीटर लेता है और सजाए गए फ़ंक्शन को मानों के साथ कॉल करता है
1 से बढ़ा हुआ । जब सजाया गया इसके अलावा मान 1 और 1 के साथ अंत कहा जाता है
परिणाम 4 होगा (1 + 1 + 1 + 1).

=> (defn इंक-डेकोरेटर [func]
... (fn [मान-1 मान-2] (func (+ मान-1 1) (+ मान-2 1))))
=> (defn inc2-डेकोरेटर [func]
... (fn [मान-1 मान-2] (func (+ मान-1 2) (+ मान-2 2))))

=> (विथ-डेकोरेटर इंक-डेकोरेटर (डिफेन एडिशन [ए बी] (+ ए बी)))
=> (अतिरिक्त 1 1)
4
=> (विथ-डेकोरेटर इंक2-डेकोरेटर इंक-डेकोरेटर
... (परिभाषा जोड़ [ए बी] (+ ए बी)))
=> (अतिरिक्त 1 1)
8

with-gensyms
संस्करण 0.9.12 में नया।

with-gensym का एक सेट उत्पन्न करने के लिए उपयोग किया जाता है gensym मैक्रो में उपयोग के लिए. निम्नलिखित कोड:

(साथ-जेनसिम्स [ए बी सी]
...)

इसका विस्तार होता है:

(चलिए [[a (gensym)
[बी (जेनसिम)
[सी (जेनसिम)]]
...)

देख यह भी:
अनुभाग का उपयोग-जेनसिम

प्राप्ति
प्राप्ति जनरेटर ऑब्जेक्ट बनाने के लिए उपयोग किया जाता है जो एक या अधिक मान लौटाता है। जनरेटर
पुनरावर्तनीय है और इसलिए इसका उपयोग लूप, सूची समझ और अन्य समान में किया जा सकता है
निर्माण करती है।

समारोह यादृच्छिक संख्याएँ दिखाता है कि जनरेटर का उपयोग अनंत श्रृंखला उत्पन्न करने के लिए कैसे किया जा सकता है
असीमित मात्रा में मेमोरी का उपभोग किए बिना।

=> (गुणांक को परिभाषित करें [आधार गुणांक]
... ([[(, आधार गुणांक) के लिए (ज़िप आधार गुणांक)]]
... (उपज (* आधार गुणांक))))

=> (गुणा (श्रेणी 5) (श्रेणी 5))


=> (सूची-कॉम्प मान [मूल्य (गुणा (श्रेणी 10) (श्रेणी 10))])
[१३, १ ९, २५, २ ९, ३१, ३ 0, ४३, ४ ९, ५३, ५५]

=> (यादृच्छिक आयात करें)
=> (यादृच्छिक संख्याओं को परिभाषित करें [निम्न उच्च]
... (जबकि सच (उपज (.randint यादृच्छिक कम उच्च))))
=> (सूची-कॉम्प x [x (15 लें (यादृच्छिक-संख्या 1 50))])])
[7, 41, 6, 22, 32, 17, 5, 38, 18, 38, 17, 14, 23, 23, 19]

उपज-से
संस्करण 0.9.13 में नया।

अजगर 3.3 और UP केवल!

उपज-से सबजेनरेटर को कॉल करने के लिए उपयोग किया जाता है। यदि आप चाहते हैं कि आपका कोरआउटाइन हो तो यह उपयोगी है
अपनी प्रक्रियाओं को किसी अन्य कोरआउटिन को सौंपने में सक्षम हो, मान लीजिए, यदि कुछ फैंसी जैसा उपयोग कर रहा हो
asyncio.

Hy मूल
मूल कार्य
लेकिनअंतिम
उपयोग: (लेकिनअंतिम कोल)

अंतिम आइटम को छोड़कर सभी का पुनरावर्तक लौटाता है coll.

=> (सूची (लेकिन अंतिम (श्रेणी 10)))
[०, १, २, ३, ४, ६, ७, ८, ९]

=> (सूची (लेकिन अंतिम [1]))
[]

=> (सूची (लेकिनअंतिम []))
[]

=> (आयात itertools)
=> (सूची (5 लें (लेकिन अंतिम (itertools.count 10))))
[10, 11, 12, 13, 14]

कोल?
संस्करण 0.10.0 में नया।

उपयोग: (कॉल? x)

रिटर्न यह सच है if x पुनरावर्तनीय है और एक स्ट्रिंग नहीं है।

=> (कॉल? [1 2 3 4])
यह सच है

=> (कॉल? {"ए" 1 "बी" 2})
यह सच है

=> (कॉल? "एबीसी")
झूठा

विपक्ष
संस्करण 0.10.0 में नया।

उपयोग: (दोष a b)

कार के साथ एक ताजा कॉन्स सेल लौटाता है a और सी.डी.आर b.

=> (setv a (cons 'hd 'tl))

=> (= 'एचडी (कार ए))
यह सच है

=> (= 'टीएल (सीडीआर ए))
यह सच है

दोष?
संस्करण 0.10.0 में नया।

उपयोग: (दोष? फू)

जाँचता है कि क्या foo एक विपक्ष कक्ष है.

=> (setv a (cons 'hd 'tl))

=> (विपक्ष? ए)
यह सच है

=> (विपक्ष? शून्य)
झूठा

=> (विपक्ष? [1 2 3])
झूठा

दिसम्बर
उपयोग: (दिसंबर) x)

से एक कम लौटाता है x. के बराबर (- x 1). जन्म देती है त्रुटि प्रकार if (नहीं (संख्यात्मक? एक्स)).

=> (3 दिसंबर)
2

=> (0 दिसंबर)
-1

=> (12.3 दिसंबर)
11.3

अलग करना
संस्करण 0.10.0 में नया।

उपयोग: (अलग करना पेड़ &वैकल्पिक [कोडेजन असत्य])

दिए गए Hy के लिए Python AST को डंप करें पेड़ मानक आउटपुट के लिए. अगर कोडजन is यह सच है, कार्यक्रम
इसके बजाय पायथन कोड प्रिंट करता है।

=> (अलग करें '(प्रिंट करें "हैलो वर्ल्ड!"))
मापांक(
शरीर=[
एक्सपीआर(मान=कॉल(func=नाम(आईडी='प्रिंट'), args=[Str(s='हैलो वर्ल्ड!')], कीवर्ड्स=[], स्टारार्ग्स=कोई नहीं, क्वार्ग्स=कोई नहीं))])

=> (अलग करें '(प्रिंट करें "हैलो वर्ल्ड!") सत्य)
प्रिंट करें ('हैलो वर्ल्ड!')

खाली?
उपयोग: (खाली? कोल)

रिटर्न यह सच है if coll खाली है। के बराबर (= 0 (लेन कोल)).

=> (खाली? [])
यह सच है

=> (खाली? "")
यह सच है

=> (खाली? (, 1 2))
झूठा

प्रत्येक?
संस्करण 0.10.0 में नया।

उपयोग: (प्रत्येक? से पहले कोल)

रिटर्न यह सच है if (पूर्व x) प्रत्येक के लिए तार्किक रूप से सत्य है x in coll, अन्यथा झूठा। वापसी यह सच है
if coll खाली है।

=> (प्रत्येक? सम? [2 4 6])
यह सच है

=> (प्रत्येक? सम? [1 3 5])
झूठा

=> (प्रत्येक? सम? [2 4 5])
झूठा

=> (प्रत्येक? सम? [])
यह सच है

तैरना?
उपयोग: (तैरना? x)

रिटर्न यह सच है if x एक फ्लोट है.

=> (फ्लोट? 3.2)
यह सच है

=> (फ्लोट? -2)
झूठा

यहां तक ​​की?
उपयोग: (यहां तक ​​की? x)

रिटर्न यह सच है if x सम है। जन्म देती है त्रुटि प्रकार if (नहीं (संख्यात्मक? एक्स)).

=> (सम? 2)
यह सच है

=> (सम? 13)
झूठा

=> (सम? 0)
यह सच है

पहचान
उपयोग: (पहचान x)

फ़ंक्शन को दिया गया तर्क लौटाता है.

=> (पहचान 4)
4

=> (सूची (मानचित्र पहचान [1 2 3 4]))
[1 2 3 4]

कांग्रेस
उपयोग: (इंक x)

से एक अधिक लौटाता है x. के बराबर (+ x 1). जन्म देती है त्रुटि प्रकार if (नहीं (संख्यात्मक? एक्स)).

=> (इंक 3)
4

=> (इंक 0)
1

=> (इंक 12.3)
13.3

उदाहरण?
उपयोग: (उदाहरण? कक्षा x)

रिटर्न यह सच है if x का एक उदाहरण है कक्षा.

=> (उदाहरण? फ़्लोट 1.0)
यह सच है

=> (उदाहरण? int 7)
यह सच है

=> (उदाहरण? str (str "foo"))
यह सच है

=> (डिफक्लास टेस्टक्लास [ऑब्जेक्ट])
=> (सेटव इंस्टा (टेस्टक्लास))
=> (उदाहरण? टेस्टक्लास उदाहरण)
यह सच है

पूर्णांक?
उपयोग: (पूर्णांक? x)

रिटर्न यह सच है if x एक पूर्णांक है. पायथन 2 के लिए, यह या तो है int or लंबा. पायथन 3 के लिए,
यह है int.

=> (पूर्णांक? 3)
यह सच है

=> (पूर्णांक? -2.4)
झूठा

बीच में छोड़ना
संस्करण 0.10.1 में नया।

उपयोग: (इंटरलीव seq1 seq2 ...)

प्रत्येक अनुक्रम में पहले आइटम का, फिर दूसरे, आदि का पुनरावर्तनीय लौटाता है।

=> (सूची (इंटरलीव (रेंज 5) (रेंज 100 105)))
[१३, १ ९, २५, २ ९, ३१, ३ 0, ४३, ४ ९, ५३, ५५]

=> (सूची (इंटरलीव (रेंज 1000000) "एबीसी"))
[0, 'ए', 1, 'बी', 2, 'सी']

जड़ना
संस्करण 0.10.1 में नया।

उपयोग: (हस्तक्षेप मद seq)

आइटम द्वारा अलग किए गए अनुक्रम के तत्वों का पुनरावर्तनीय लौटाता है।

=> (सूची (प्रस्ताव "!" "एबीसीडी"))
['ए बी सी डी']

=> (सूची (इंटरपोज़ -1 (रेंज 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

पुनरावर्तनीय?
उपयोग: (पुनरावर्तनीय? x)

रिटर्न यह सच है if x पुनरावर्तनीय है. पुनरावर्तनीय वस्तुएं एक नया पुनरावर्तक लौटाती हैं जब (इटर x) is
बुलाया। साथ इसके विपरीत पुनरावर्तक?.

=> ;; स्ट्रिंग्स के लिए काम करता है
=> (पुनरावर्तनीय? (str "abcde"))
यह सच है

=> ;; सूचियों के लिए काम करता है
=> (पुनरावर्तनीय? [1 2 3 4 5])
यह सच है

=> ;; टुपल्स के लिए काम करता है
=> (पुनरावर्तनीय? (, 1 2 3))
यह सच है

=> ;; तानाशाही के लिए काम करता है
=> (पुनरावर्तनीय? {:ए 1 :बी 2 :सी 3})
यह सच है

=> ;; इटरेटर/जनरेटर के लिए काम करता है
=> (पुनरावर्तनीय? (दोहराएँ 3))
यह सच है

पुनरावर्तक?
उपयोग: (पुनरावर्तक? x)

रिटर्न यह सच है if x एक पुनरावर्तक है. इटरेटर वे वस्तुएं हैं जो स्वयं को एक के रूप में लौटाती हैं
पुनरावर्तक कब (इटर x) कहा जाता है। साथ इसके विपरीत पुनरावर्तनीय?.

=> ;; किसी सूची के लिए काम नहीं करता
=> (पुनरावर्तक? [1 2 3 4 5])
झूठा

=> ;; लेकिन हम सूची से पुनरावृत्त प्राप्त कर सकते हैं
=> (पुनरावर्तक? (पुनरावर्तक [1 2 3 4 5]))
यह सच है

=> ;; हुक्म के लिए काम नहीं करता
=> (पुनरावर्तक? {:a 1 :b 2 :c 3})
झूठा

=> ;; निर्देश से एक पुनरावर्तक बनाएँ
=> (पुनरावर्तक? (iter {:a 1 :b 2 :c 3}))
यह सच है

सूची*
उपयोग: (सूची* सिर &आराम पूँछ)

तर्कों से युक्त नेस्टेड विपक्ष कोशिकाओं (एक बिंदीदार सूची) की एक श्रृंखला उत्पन्न करता है। यदि
तर्क सूची में केवल एक तत्व है, इसे वापस लौटाएँ।

=> (सूची* 1 2 3 4)
(1 2 3 .4)

=> (सूची* 1 2 3 [4])
[०, २, १, ०]

=> (सूची* 1)
1

=> (विपक्ष? (सूची* 1 2 3 4))
यह सच है

मैक्रोविस्तार
संस्करण 0.10.0 में नया।

उपयोग: (मैक्रोएक्सपैंड प्रपत्र)

का पूर्ण मैक्रो विस्तार लौटाता है प्रपत्र.

=> (मैक्रोएक्सपैंड '(-> (ए बी) (एक्स वाई)))
(u'x' (u'a' u'b') u'y')

=> (मैक्रोएक्सपैंड '(-> (ए बी) (-> (सी डी) (ई एफ))))
(u'e' (u'c' (u'a' u'b') u'd') u'f')

मैक्रोएक्सपैंड-1
संस्करण 0.10.0 में नया।

उपयोग: (मैक्रोएक्सपैंड-1 प्रपत्र)

का एकल चरण मैक्रो विस्तार लौटाता है प्रपत्र.

=> (मैक्रोएक्सपैंड-1 '(-> (ए बी) (-> (सी डी) (ई एफ))))
(u'_>' (u'a' u'b') (u'c' u'd') (u'e' u'f'))

इसके साथ मर्ज करें
संस्करण 0.10.1 में नया।

उपयोग: (इसके साथ मर्ज करें f &आराम मानचित्र)

एक मानचित्र लौटाता है जिसमें पहले जुड़े हुए शेष मानचित्र शामिल होते हैं। यदि कोई कुंजी आती है
एक से अधिक मानचित्र, बाद वाले (बाएं से दाएं) के मानचित्रणों को एक साथ जोड़ दिया जाएगा
कॉल करके परिणाम में मैपिंग (f वैल-इन-परिणाम वैल-इन-लैटर).

=> (मर्ज-विथ (एफएन [एक्स वाई] (+ एक्स वाई)) {"ए" 10 "बी" 20} {"ए" 1 "सी" 30})
{यू'ए': 11एल, यू'सी': 30एल, यू'बी': 20एल}

नकारात्मक?
उपयोग: (नकारात्मक? x)

रिटर्न यह सच है if x शून्य से कम है. जन्म देती है त्रुटि प्रकार if (नहीं (संख्यात्मक? एक्स)).

=> (नकारात्मक? -2)
यह सच है

=> (नकारात्मक? 3)
झूठा

=> (नकारात्मक? 0)
झूठा

शून्य?
उपयोग: (शून्य? x)

रिटर्न यह सच है if x is शून्य / कोई नहीं.

=> (शून्य? शून्य)
यह सच है

=> (शून्य? कोई नहीं)
यह सच है

=> (शून्य? 0)
झूठा

=> (सेटफ़ x शून्य)
=> (शून्य? x)
यह सच है

=> ;; list.append हमेशा कोई नहीं लौटाता
=> (शून्य? (.संलग्न करें [1 2 3] 4))
यह सच है

कोई नहीं?
उपयोग: (कोई नहीं? x)

रिटर्न यह सच है if x is कोई नहीं.

=> (कोई नहीं? कोई नहीं)
यह सच है

=> (कोई नहीं? 0)
झूठा

=> (सेटफ़ x कोई नहीं)
=> (कोई नहीं? x)
यह सच है

=> ;; list.append हमेशा कोई नहीं लौटाता
=> (कोई नहीं? (.संलग्न करें [1 2 3] 4))
यह सच है

n वें
उपयोग: (एनवां coll n &वैकल्पिक [चूक जाना शून्य])

लौटता है nसंग्रह में -वाँ आइटम, 0 से गिनती। डिफ़ॉल्ट मान लौटाएँ, शून्य, अगर
सीमा से बाहर (जब तक कि अन्यथा निर्दिष्ट न हो)। जन्म देती है मान if n नकारात्मक है।

=> (एनवां [1 2 4 7] 1)
2

=> (एनवां [1 2 4 7] 3)
7

=> (शून्य? (एनवां [1 2 4 7] 5))
यह सच है

=> (एनवां [1 2 4 7] 5 "डिफ़ॉल्ट")
'चूक जाना'

=> (एनवां (3 लें (ड्रॉप 2 [1 2 3 4 5 6])) 2))
5

=> (एनवां [1 2 4 7] -1)
ट्रेसबैक (सबसे हालिया कॉल अंतिम):
...
वैल्यूएरर: आइसलाइस() के लिए सूचकांक कोई नहीं या एक पूर्णांक होना चाहिए: 0 <= x <= sys.maxsize।

संख्यात्मक?
उपयोग: (संख्यात्मक? x)

रिटर्न यह सच है if x एक संख्यात्मक है, जैसा कि पायथन में परिभाषित किया गया है नंबर.संख्या वर्ग.

=> (संख्यात्मक? -2)
यह सच है

=> (संख्यात्मक? 3.2)
यह सच है

=> (संख्यात्मक? "फू")
झूठा

विषम?
उपयोग: (विषम? x)

रिटर्न यह सच है if x अजीब है। जन्म देती है त्रुटि प्रकार if (नहीं (संख्यात्मक? एक्स)).

=> (विषम? 13)
यह सच है

=> (विषम? 2)
झूठा

=> (विषम? 0)
झूठा

स्थिति?
उपयोग: (स्थिति? x)

रिटर्न यह सच है if x शून्य से बड़ा है. जन्म देती है त्रुटि प्रकार if (नहीं (संख्यात्मक? एक्स)).

=> (स्थिति 3)
यह सच है

=> (स्थिति? -2)
झूठा

=> (स्थिति 0)
झूठा

दूसरा
उपयोग: (दूसरा कोल)

का दूसरा सदस्य लौटाता है coll. के बराबर (प्राप्त coll 1).

=> (दूसरा [0 1 2])
1

कुछ
संस्करण 0.10.0 में नया।

उपयोग: (कुछ से पहले कोल)

का पहला तार्किक रूप से सही मान लौटाता है (पूर्व x) किसी के लिए x in coll, अन्यथा शून्य.
वापसी शून्य if coll खाली है।

=> (कुछ सम भी? [2 4 6])
यह सच है

=> (शून्य? (कुछ सम भी? [1 3 5]))
यह सच है

=> (शून्य? (कुछ पहचान [0 "" []]))
यह सच है

=> (कुछ पहचान [0 "गैर-रिक्त-स्ट्रिंग" []])
'गैर-रिक्त-स्ट्रिंग'

=> (शून्य? (कुछ भी? []))
यह सच है

स्ट्रिंग?
उपयोग: (डोरी? x)

रिटर्न यह सच है if x एक स्ट्रिंग है।

=> (स्ट्रिंग? "फू")
यह सच है

=> (स्ट्रिंग? -2)
झूठा

प्रतीक?
उपयोग: (प्रतीक? x)

रिटर्न यह सच है if x एक प्रतीक है.

=> (प्रतीक? 'फू)
यह सच है

=> (प्रतीक? '[ए बी सी])
झूठा

शून्य?
उपयोग: (शून्य? x)

रिटर्न यह सच है if x शून्य है

=> (शून्य? 3)
झूठा

=> (शून्य? -2)
झूठा

=> (शून्य? 0)
यह सच है

अनुक्रम कार्य
अनुक्रम फ़ंक्शंस या तो संभावित अनंत अनुक्रम के बिना बना या संचालित कर सकते हैं
अनुक्रम को किसी सूची या समान कंटेनर में पूरी तरह से महसूस करने की आवश्यकता होती है। वे ऐसा करते हैं
एक पायथन इटरेटर लौटा रहा हूँ।

हम कैनोनिकल अनंत फाइबोनैचि संख्या जनरेटर का उपयोग कैसे करें के उदाहरण के रूप में कर सकते हैं
इनमें से कुछ कार्य.

(defn fib []
(सेटव ए 0)
(सेटव बी 1)
(जबकि सच है
(उपज ए)
(सेटव (, एबी) (, बी (+ एबी)))))

ध्यान दें (जबकि <strong>उद्देश्य</strong> ...) कुंडली। यदि हम इसे आरईपीएल में चलाते हैं,

=> (फ़ाइब)


फ़ंक्शन को कॉल करने से केवल एक पुनरावर्तक मिलता है, लेकिन जब तक हम इसका उपभोग नहीं करते तब तक कोई काम नहीं करता।
ऐसा कुछ आज़माने की अनुशंसा नहीं की जाती है क्योंकि अनंत लूप तब तक चलेगा
सभी उपलब्ध रैम का उपभोग करता है, या इस मामले में जब तक मैंने इसे खत्म नहीं कर दिया।

=> (सूची (फाइब))
[1] 91474 मारे गए

प्रथम 10 फाइबोनैचि संख्याएँ प्राप्त करने के लिए, उपयोग करें लेना। ध्यान दें कि लेना एक जनरेटर भी लौटाता है,
इसलिए मैं इससे एक सूची बनाता हूं।

=> (सूची (10 (फ़ाइब) लें))
[१३, १ ९, २५, २ ९, ३१, ३ 0, ४३, ४ ९, ५३, ५५]

सूचकांक 9 पर फाइबोनैचि संख्या प्राप्त करने के लिए, (0 से प्रारंभ):

=> (एनवां (फाइब) 9)
34

चक्र
उपयोग: (चक्र कोल)

कोल के सदस्यों का एक अनंत पुनरावर्तक लौटाता है।

=> (सूची (7 लें (चक्र [1 2 3])))
[1, 2, 3, 1, 2, 3, 1]

=> (सूची (2 लें (चक्र [1 2 3])))
[1, 2]

अलग
उपयोग: (विशिष्ट कोल)

एक पुनरावर्तक लौटाता है जिसमें केवल अद्वितीय सदस्य होते हैं coll.

=> (सूची (विशिष्ट [1 2 3 4 3 5 2 ]))
[1, 2, 3, 4, 5]

=> (सूची (विशिष्ट []))
[]

=> (सूची (विशिष्ट (इटर [1 2 3 4 3 5 2 XNUMX ])))
[1, 2, 3, 4, 5]

बूंद
उपयोग: (बूँद n कोल)

पहले को छोड़कर, एक पुनरावर्तक लौटाता है n के सदस्यों coll. जन्म देती है मान if n is
नकारात्मक।

=> (सूची (ड्रॉप 2 [1 2 3 4 5]))
[3, 4, 5]

=> (सूची (ड्रॉप 4 [1 2 3 4 5]))
[5]

=> (सूची (ड्रॉप 0 [1 2 3 4 5]))
[1, 2, 3, 4, 5]

=> (सूची (ड्रॉप 6 [1 2 3 4 5]))
[]

ड्रॉप-लास्ट
उपयोग: (ड्रॉप-लास्ट n कोल)

अंतिम को छोड़कर सभी का पुनरावर्तक लौटाता है n में आइटम coll. जन्म देती है मान if n is
नकारात्मक।

=> (सूची (ड्रॉप-लास्ट 5 (रेंज 10 20)))
[10, 11, 12, 13, 14]

=> (सूची (ड्रॉप-अंतिम 0 (श्रेणी 5)))
[0, 1, 2, 3, 4]

=> (सूची (ड्रॉप-अंतिम 100 (श्रेणी 100)))
[]

=> (आयात itertools)
=> (सूची (5 लें (ड्रॉप-लास्ट 100 (itertools.count 10))))
[10, 11, 12, 13, 14]

ड्रॉप-जबकि
उपयोग: (ड्रॉप-जबकि से पहले कोल)

के सदस्यों को छोड़कर, एक पुनरावर्तक लौटाता है coll जब तक से पहले is झूठा.

=> (सूची (ड्रॉप-व्हाइल सम? [2 4 7 8 9]))
[7, 8, 9]

=> (सूची (ड्रॉप-व्हाइल संख्यात्मक? [1 2 3 कोई नहीं "ए"])))
[कोई नहीं, आप']

=> (सूची (ड्रॉप-व्हाइल पॉज़? [2 4 7 8 9]))
[]

फ़िल्टर
उपयोग: (फ़िल्टर से पहले कोल)

सभी आइटमों के लिए एक पुनरावर्तक लौटाता है coll जो विधेय को पार करता है से पहले.

यह भी देखें हटाना.

=> (सूची (फ़िल्टर स्थिति? [1 2 3 -4 5 -7]))
[०, २, १, ०]

=> (सूची (फ़िल्टर भी? [1 2 3 -4 5 -7]))
[2, -4]

समतल करना
संस्करण 0.9.12 में नया।

उपयोग: (चपटा करें कोल)

सभी आइटमों की एक एकल सूची लौटाता है coll, सभी निहित सूचियों को समतल करके और/या
टुपल्स

=> (चपटा करें [1 2 [3 4] 5])
[1, 2, 3, 4, 5]

=> (चपटा करें ["फू" (, 1 2) [1 [2 3] 4] "बार"])
['फू', 1, 2, 1, 2, 3, 4, 'बार']

पुनरावृति
उपयोग: (पुनरावृत्ति fn x)

का पुनरावर्तक लौटाता है x, एफएन(एक्स), एफएन(एफएन(एक्स)), आदि

=> (सूची (5 लें (5 सहित पुनरावृत्त करें)))
[5, 6, 7, 8, 9]

=> (सूची (5 लें (पुनरावृत्ति (fn [x] (* x x)) 5)))
[5, 25, 625, 390625, 152587890625]

पढ़ना
उपयोग: (पढ़ &वैकल्पिक [लेख्यपत्र से ईओएफ])

से अगली Hy अभिव्यक्ति पढ़ता है लेख्यपत्र से (डिफ़ॉल्ट रूप से sys.stdin), और एक ले सकते हैं
ईओएफ के रूप में एकल बाइट (एक खाली स्ट्रिंग पर डिफ़ॉल्ट)। जन्म देती है EOFत्रुटि if लेख्यपत्र से से पहले समाप्त होता है
एक संपूर्ण अभिव्यक्ति को पार्स किया जा सकता है.

=> (पढ़ें)
(+2 2)
('+' 2 2)
=> (eval (पढ़ें))
(+2 2)
4

=> (आयात io)
=> (डीईएफ़ बफ़र (io.StringIO "(+ 2 2)\n(- 2 1)"))
=> (eval (पढ़ें लागू करें [] {"from_file" बफर}))
4
=> (eval (पढ़ें लागू करें [] {"from_file" बफर}))
1

=> ; यह मानते हुए कि "example.hy" में शामिल हैं:
=> ; (प्रिंट "हैलो")
=> ; (प्रिंट "हाईफ्रेंड्स!")
=> ([[f (खुले "example.hy") के साथ]]
... (कोशिश
... (जबकि सच है
... (चलिए [[exp (f पढ़ें)]]
... (करना
... (प्रिंट "ओएचवाई" ऍक्स्प)
... (eval exp))))
... (पकड़ो [e EOFError]
... (प्रिंट "ईओएफ!"))))
OHY ('प्रिंट' 'हैलो')
नमस्ते
ओह ('प्रिंट' 'हाईफ्रेंड्स!')
हाईफ्रेंड्स!
ईओएफ!

हटाना
उपयोग: (निकालना से पहले कोल)

से एक पुनरावर्तक लौटाता है coll उन तत्वों के साथ जो विधेय को पार करते हैं, से पहले, निकाला गया।

यह भी देखें फ़िल्टर.

=> (सूची (विषम हटाएं? [1 2 3 4 5 6 7]))
[2, 4, 6]

=> (सूची (स्थिति हटाएं? [1 2 3 4 5 6 7]))
[]

=> (सूची (नकारात्मक हटाएं? [1 2 3 4 5 6 7]))
[1, 2, 3, 4, 5, 6, 7]

दोहराना
उपयोग: (दोहराना x)

का एक पुनरावर्तक (अनंत) लौटाता है x.

=> (सूची (6 लें ("s" दोहराएँ)))
[तुम', तुम', तुम', तुम', तुम', तुम']

बार-बार
उपयोग: (बार-बार एफएन)

कॉल करके एक पुनरावर्तक लौटाता है fn बार-बार।

=> (आयात [यादृच्छिक [रैंडिंट]])

=> (सूची (5 लें (बार-बार (fn [] (randint 0 10)))))
[6, 2, 0, 6, 7]

लेना
उपयोग: (लेना n कोल)

पहला वाला पुनरावर्तक लौटाता है n के सदस्यों coll. जन्म देती है मान if n is
नकारात्मक।

=> (सूची (3 लें [1 2 3 4 5]))
[1, 2, 3]

=> (सूची (4 लें ("s" दोहराएँ)))
[तुम', तुम', तुम', तुम']

=> (सूची (0 लें ("s" दोहराएँ)))
[]

टेक-एनवां
उपयोग: (टेक-एनवें n कोल)

प्रत्येक युक्त एक पुनरावर्तक लौटाता है n-वें सदस्य coll.

=> (सूची (ले-एनवां 2 [1 2 3 4 5 6 7]))
[०, २, १, ०]

=> (सूची (ले-एनवां 3 [1 2 3 4 5 6 7]))
[1, 4, 7]

=> (सूची (ले-एनवां 4 [1 2 3 4 5 6 7]))
[1, 5]

=> (सूची (ले-एनवां 10 [1 2 3 4 5 6 7]))
[1]

कुछ देर ले लो
उपयोग: (थोड़ा समय लें से पहले कोल)

से एक पुनरावर्तक लौटाता है coll जब तक से पहले रिटर्न यह सच है.

=> (सूची (समय-समय पर स्थिति? [1 2 3 -4 5]))
[1, 2, 3]

=> (सूची (समय-समय पर नकारात्मक? [-4 -3 1 2 5]))
[-4, -3]

=> (सूची (समय-समय पर नकारात्मक? [1 2 3 -4 5]))
[]

zipwith
संस्करण 0.9.13 में नया।

उपयोग: (ज़िपविथ fn coll ...)

के बराबर ज़िप, लेकिन टुपल बनाने के बजाय बहु-तर्क फ़ंक्शन का उपयोग करता है। अगर
zipwith फिर, एन संग्रह के साथ बुलाया जाता है fn एन तर्कों को स्वीकार करना होगा।

=> (आयात ऑपरेटर)
=> (सूची (ऑपरेटर के साथ ज़िप। जोड़ें [1 2 3] [4 5 6]))
[5, 7, 9]

पाठक मैक्रोज़
रीडर मैक्रोज़ लिस्प को तुरंत सिंटैक्स को संशोधित करने और बदलने की शक्ति देता है। आप नहीं चाहते
पोलिश संकेतन? एक रीडर मैक्रो आसानी से ऐसा कर सकता है। क्लोजर का तरीका चाहते हैं
रेगेक्स? रीडर मैक्रोज़ भी यह काम आसानी से कर सकते हैं.

वाक्य - विन्यास
=> (डिफ़्रेडर ^ [एक्सपीआर] (प्रिंट एक्सपीआर))
=> #^(1 2 3 4)
(०1०० १६ २५ ५०)
=> #^"हैलो"
"नमस्ते"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

Hy के पास टुपल्स के लिए कोई शाब्दिक अर्थ नहीं है। मान लीजिए कि आपको नापसंद है (, ...) और कुछ और चाहते हैं. यह
यह एक समस्या है जिसे रीडर मैक्रोज़ साफ-सुथरे तरीके से हल करने में सक्षम हैं।

=> (डिफ़्रेडर टी [एक्सपीआर] `(, ~@एक्सपीआर))
=> #t(1 2 3)
(1, 2, 3)

आप इसे क्लोजर की तरह भी कर सकते हैं और नियमित अभिव्यक्तियों के लिए शाब्दिक अर्थ रख सकते हैं!

=> (फिर से आयात करें)
=> (डिफ़्रेडर आर [एक्सपीआर] `(पुनः संकलन ~एक्सपीआर))
=> #r"।*"
पर

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

=> (डिफ़्रेडर ^ [एक्सपीआर] (प्रिंट एक्सपीआर))
;=> (with_decorator (hy.macros.reader ^) (fn [expr] (प्रिंट expr)))

# में फैलता है (डिस्पैच_रीडर_मैक्रो ...) जहां प्रतीक और अभिव्यक्ति को पारित किया जाता है
सही कार्य.

=> #^()
;=> (डिस्पैच_रीडर_मैक्रो ^ ())
=> #^"हैलो"
"नमस्ते"

चेतावनी:
Hy के लेक्सर और पार्सर में एक सीमा के कारण, रीडर मैक्रोज़ परिभाषित को फिर से परिभाषित नहीं कर सकते हैं
वाक्यविन्यास जैसे ()[]{}. संभवतः भविष्य में इस पर ध्यान दिया जाएगा।

आंतरिक Hy प्रलेखन
नोट:
ये बिट्स ज्यादातर उन लोगों के लिए उपयोगी हैं जो हाई पर ही हैक करते हैं, लेकिन इनका उपयोग इसके लिए भी किया जा सकता है
जो मैक्रो प्रोग्रामिंग में गहराई से उतरते हैं।

Hy मॉडल
परिचय सेवा मेरे Hy मॉडल
Hy मॉडल नियमित Python ऑब्जेक्ट के ऊपर एक बहुत पतली परत होती है, जो Hy स्रोत का प्रतिनिधित्व करती है
डेटा के रूप में कोड. मॉडल केवल स्रोत स्थिति की जानकारी और कुछ तरीके जोड़ते हैं
उदाहरण के लिए, मैक्रोज़ में हाई सोर्स कोड के स्वच्छ हेरफेर का समर्थन करें। उसे हासिल करने के लिए
लक्ष्य, हाई मॉडल बेस पायथन वर्ग के मिश्रण हैं और हाईऑब्जेक्ट.

हाईऑब्जेक्ट
hy.models.HyObject हाई मॉडल का आधार वर्ग है। यह केवल एक विधि लागू करता है, की जगह,
जो वर्तमान वस्तु की स्रोत स्थिति को तर्क के रूप में पारित वस्तु से बदल देता है।
यह हमें उन अभिव्यक्तियों की मूल स्थिति पर नज़र रखने की अनुमति देता है जिन्हें संशोधित किया जाता है
मैक्रोज़, चाहे वह कंपाइलर में हो या शुद्ध हाई मैक्रोज़ में।

हाईऑब्जेक्ट इसका उपयोग सीधे तौर पर Hy मॉडल को इंस्टेंट करने के लिए नहीं किया गया है, बल्कि केवल एक मिश्रण के रूप में किया गया है
अन्य वर्गों के लिए.

यौगिक मॉडल
कोष्ठक और ब्रैकेट वाली सूचियों को हाई पार्सर द्वारा मिश्रित मॉडल के रूप में पार्स किया गया है।

हाईलिस्ट
hy.models.list.HyList "पुनरावर्तनीय" हाई मॉडल का आधार वर्ग है। इसका मूल उपयोग है
कोष्ठक में दर्शाया गया है [] सूचियाँ, जो, जब शीर्ष-स्तरीय अभिव्यक्ति के रूप में उपयोग की जाती हैं, तो अनुवादित हो जाती हैं
संकलन चरण में पायथन सूची शाब्दिक।

किसी अन्य पुनरावर्तनीय वस्तु में HyList जोड़ने से बायीं ओर की वस्तु के वर्ग का पुन: उपयोग होता है,
उदाहरण के लिए, जब आप किसी मैक्रो में Hy ऑब्जेक्ट को जोड़ना चाहते हैं तो यह एक उपयोगी व्यवहार है।

हाईएक्सप्रेशन
hy.models.expression.hyexpression inherits हाईलिस्ट कोष्ठक के लिए () भाव.
उन अभिव्यक्तियों का संकलन परिणाम सूची के पहले तत्व पर निर्भर करता है:
कंपाइलर कंपाइलर विशेष-रूपों, उपयोगकर्ता-परिभाषित मैक्रोज़ और के बीच अभिव्यक्ति भेजता है
नियमित पायथन फ़ंक्शन कॉल।

हाइडिक्ट
hy.models.dict.HyDict inherits हाईलिस्ट घुंघराले-कोष्ठक के लिए {} अभिव्यक्तियाँ, जो संकलित करती हैं
शाब्दिक रूप से पायथन शब्दकोश तक।

आधार वर्ग के रूप में निर्देश के बजाय सूची का उपयोग करने का निर्णय हाइडिक्ट आसान अनुमति देता है
यौगिक अभिव्यक्तियों की अनुमति के अतिरिक्त लाभ के साथ, मैक्रोज़ में डिक्ट्स का हेरफेर
तानाशाही कुंजियों के रूप में (उदाहरण के लिए, हाईएक्सप्रेशन पायथन क्लास धोने योग्य नहीं है)।

परमाणु मॉडल
इनपुट स्ट्रीम में, स्ट्रिंग्स के लिए पायथन नोटेशन का सम्मान करते हुए, डबल-उद्धृत स्ट्रिंग्स,
एकल टोकन के रूप में पार्स किया जाता है, जिसे सीधे एक के रूप में पार्स किया जाता है हाईस्ट्रिंग.

रिक्त स्थान, कोष्ठक, उद्धरण, दोहरे-उद्धरण को छोड़कर, वर्णों की एक निर्बाध श्रृंखला
और टिप्पणियाँ, एक पहचानकर्ता के रूप में पार्स किया गया है।

निम्नलिखित क्रम में पार्सिंग चरण के दौरान पहचानकर्ताओं को परमाणु मॉडल में हल किया जाता है:

· हाइइंटेगर

· हाईफ्लोट

· हाईकॉम्प्लेक्स (यदि परमाणु नग्न नहीं है j)

· हाईकीवर्ड (यदि परमाणु शुरू होता है :)

· HySymbol

हाईस्ट्रिंग
hy.models.string.HyString स्ट्रिंग-समतुल्य Hy मॉडल का आधार वर्ग है। यह भी
दोहरे-उद्धृत स्ट्रिंग अक्षर का प्रतिनिधित्व करता है, "", जो यूनिकोड स्ट्रिंग में संकलित होता है
पायथन में शाब्दिक। हाईस्ट्रिंग्स पायथन 2 में यूनिकोड ऑब्जेक्ट और स्ट्रिंग ऑब्जेक्ट इनहेरिट करें
पायथन 3 (और इसलिए एन्कोडिंग-निर्भर नहीं हैं)।

हाईस्ट्रिंग आधारित मॉडल अपरिवर्तनीय हैं।

हाई शाब्दिक तार कई पंक्तियों तक फैल सकते हैं, और पार्सर द्वारा उन्हें एकल माना जाता है
इकाई, यूनिकोड स्ट्रिंग्स के लिए पायथन एस्केप का सम्मान करती है।

सांख्यिक मॉडल
hy.models.integer.HyInteger पूर्णांक अक्षर का प्रतिनिधित्व करता है (का उपयोग करके)। लंबा Python 2 पर टाइप करें,
और int पायथन 3 पर)।

hy.models.float.HyFloat फ़्लोटिंग-पॉइंट अक्षर का प्रतिनिधित्व करता है।

hy.models.complex.HyComplex जटिल शाब्दिक प्रतिनिधित्व करता है.

संख्यात्मक मॉडल को संबंधित पायथन रूटीन और वैध संख्यात्मक पायथन का उपयोग करके पार्स किया जाता है
शाब्दिक को उनके हाई समकक्ष में बदल दिया जाएगा।

HySymbol
hy.models.symbol.HySymbol हाई भाषा में प्रतीकों का प्रतिनिधित्व करने के लिए उपयोग किया जाने वाला मॉडल है। यह
inherits हाईस्ट्रिंग.

HySymbol पायथन इंटरऑपरेबिलिटी में मदद के लिए, वस्तुओं को पार्सिंग चरण में उलझा दिया जाता है:

· तारांकन से घिरे प्रतीक (*) अपरकेस में बदल दिए जाते हैं;

· डैश (-) को अंडरस्कोर में बदल दिया जाता है (_);

· एक पिछला प्रश्न चिह्न (?) को अग्रणी में बदल दिया गया है है_.

चेतावनी: चूंकि पार्सिंग चरण के दौरान मैंगलिंग की जाती है, इसलिए यह संभव है
प्रोग्रामेटिक रूप से HySymbols उत्पन्न करें जिन्हें Hy स्रोत कोड के साथ उत्पन्न नहीं किया जा सकता है। ऐसा
तंत्र का उपयोग जेनसिम द्वारा "अनइंटर्नड" प्रतीकों को उत्पन्न करने के लिए किया जाता है।

हाईकीवर्ड
hy.models.keyword.HyKeyword Hy में कीवर्ड का प्रतिनिधित्व करता है। कीवर्ड से शुरू होने वाले प्रतीक हैं
a :. वर्ग विरासत में मिला है हाईस्ट्रिंग.

भेद करने के लिए हाईकीवर्ड से हाई सिंबल(अनैच्छिक) की संभावना के बिना
झड़पें, निजी उपयोग वाला यूनिकोड वर्ण "\uFDD0" शाब्दिक कीवर्ड से जुड़ा हुआ है
भंडारण से पहले।

नुकसान कोशिकाओं
hy.models.cons.HyCons पायथन-अनुकूल का प्रतिनिधित्व है विपक्ष कोशिकाओं. विपक्ष कोशिकाएं हैं
स्कीम या कॉमन जैसे "सामान्य" एलआईएसपी वेरिएंट की विशेषताओं की नकल करने के लिए विशेष रूप से उपयोगी
लिस्प.

एक कॉन्स सेल एक 2-आइटम ऑब्जेक्ट है, जिसमें a होता है कार (सिर) और ए कमांडर (पूँछ)। कुछ लिस्प में
वेरिएंट, कॉन्स सेल मौलिक बिल्डिंग ब्लॉक है, और एस-एक्सप्रेशन वास्तव में हैं
विपक्ष कोशिकाओं की लिंक्ड सूचियों के रूप में दर्शाया गया है। हाई में यह हमेशा की तरह मामला नहीं है
अभिव्यक्तियाँ पायथन सूचियों से बनी हैं जिन्हें a में लपेटा गया है हाईएक्सप्रेशन। हालांकि हाईकॉन्स
इस प्रकार "सामान्य" लिस्प वेरिएंट के व्यवहार की नकल करता है:

· (दोष कुछ शून्य) is (हाइएक्सप्रेशन [कुछ])

· (दोष कुछ कुछ-सूची) is ((प्रकार कुछ-सूची) (+ [कुछ] कुछ-सूची)) (अगर
कुछ-सूची से विरासत में मिला है सूची).

· (प्राप्त (दोष a b) 0) is a

· (टुकड़ा (दोष a b) 1) is b

Hy एक डॉटेड-लिस्ट सिंटैक्स का समर्थन करता है, जहाँ '(ए . b) साधन (दोष 'a 'बी) और '(ए b . c) साधन
(दोष 'a (दोष 'b 'सी)). यदि कंपाइलर को शीर्ष स्तर पर एक कॉन्स सेल का सामना करना पड़ता है, तो यह बढ़ जाता है
एक संकलन त्रुटि.

हाईकॉन्स हेरफेर को आसान बनाने के लिए पारित तर्कों (कार और सीडीआर) को हाई प्रकारों में लपेटता है
मैक्रो संदर्भ में विपक्ष कोशिकाएं।

Hy आंतरिक सिद्धांत
अवलोकन
हाई इंटरनल्स पायथन बाइटकोड के फ्रंट-एंड के रूप में कार्य करके काम करते हैं, ताकि हाई ही
पाइथन बाइटकोड को संकलित करता है, जिससे एक असंशोधित पायथन रनटाइम को हाई कोड चलाने की अनुमति मिलती है,
इस पर ध्यान दिए बिना भी।

जिस तरह से हम ऐसा करते हैं वह Hy को आंतरिक पायथन एएसटी डेटास्ट्रक्चर में अनुवाद करके है, और
पायथन मानक से मॉड्यूल का उपयोग करके उस एएसटी को पायथन बाइटकोड में बनाना
लाइब्रेरी, ताकि हमें प्रत्येक के लिए पायथन इंटरनल के सभी कार्यों की नकल न करनी पड़े
एकल पायथन रिलीज़।

हाई चार चरणों में काम करता है. निम्नलिखित अनुभाग स्रोत से लेकर तक Hy के प्रत्येक चरण को कवर करेंगे
रनटाइम।

कदम 1 और 2: Tokenizing और पदच्छेद
Hy को संकलित करने का पहला चरण स्रोत को टोकन में बदलना है जिससे हम निपट सकते हैं। हम
rply नामक प्रोजेक्ट का उपयोग करें, जो वास्तव में एक अच्छा (और तेज़) पार्सर है, जो एक उपसमूह में लिखा गया है
पायथन को rpython कहा जाता है।

लेक्सिंग कोड सभी में परिभाषित है hy.lex.lexer. यह कोड अधिकतर केवल Hy को परिभाषित कर रहा है
व्याकरण, और सभी वास्तविक कठिन भागों का ध्यान रप्लाई द्वारा रखा जाता है - हम बस परिभाषित करते हैं
उत्तर के लिए "कॉलबैक"। hy.lex.parser, जो उत्पन्न टोकन लेता है, और लौटाता है
हाई मॉडल.

आप Hy मॉडल को Hy के लिए "AST" के रूप में सोच सकते हैं, मैक्रोज़ इसी पर काम करते हैं
(सीधे), और कंपाइलर इसका उपयोग तब करता है जब वह हाई डाउन संकलित करता है।

देख यह भी:
अनुभाग Hy मॉडल हाई मॉडल और उनके मतलब के बारे में अधिक जानकारी के लिए।

कदम 3: Hy संकलन सेवा मेरे अजगर एएसटी
यहीं पर हाई में अधिकांश जादू होता है। यहीं पर हम Hy AST (मॉडल) लेते हैं,
और उन्हें Python AST में संकलित करें। पिछले कुछ समय से काम करने के लिए यहां कुछ मजेदार चीजें होती रहती हैं
एएसटी में समस्याएं, और कंपाइलर में काम करना हमारे द्वारा किए जाने वाले सबसे महत्वपूर्ण कार्यों में से एक है
लोगों की है।

कंपाइलर थोड़ा जटिल है, इसलिए यदि आप इसे पहले शॉट में नहीं समझ पाते हैं तो बुरा मत मानना,
इसे सही होने में थोड़ा समय लग सकता है।

कंपाइलर का मुख्य प्रवेश-बिंदु है HyASTकंपाइलर.संकलन. इस विधि को लागू किया जाता है, और
कक्षा पर एकमात्र वास्तविक "सार्वजनिक" विधि (कहने का मतलब है, हम वास्तव में इसका वादा नहीं करते हैं
एपीआई उस विधि से परे)।

वास्तव में, आंतरिक रूप से भी, हम शायद ही कभी सीधे तौर पर पुनरावृत्ति नहीं करते हैं, हम लगभग हमेशा ही दबाव डालते हैं
हाई पेड़ के माध्यम से संकलन, और अक्सर अभिव्यक्ति के उप-तत्वों के साथ ऐसा करेगा
जो हमारे पास है। उप-तत्वों को ठीक से भेजना टाइप-आधारित डिस्पैचर पर निर्भर है।

किसी संकलन को तैयार करने वाली सभी विधियों को इसके साथ चिह्नित किया जाता है @बिल्ड्स() डेकोरेटर. तुम कर सकते हो
या तो Hy मॉडल की उस कक्षा को पास करें जिसे वह संकलित करता है, या आप इसके लिए एक स्ट्रिंग का उपयोग कर सकते हैं
भाव. मैं इसे एक सेकंड में साफ़ कर दूंगा।

प्रथम ट्रेनिंग प्रकार-प्रेषण
आइये शुरू करते हैं संकलन तरीका। पहली चीज़ जो हम करते हैं वह है चीज़ के प्रकार की जाँच करना
हम निर्माण कर रहे हैं. हम यह देखने के लिए तत्पर हैं कि क्या हमारे पास कोई ऐसी विधि है जो इसका निर्माण कर सकती है प्रकार() हम चाहते हैं कि
है, और उस विधि को भेजें जो इसे संभाल सके। यदि हमारे पास ऐसा कोई तरीका नहीं है जो कर सके
उस प्रकार का निर्माण करें, हम एक आंतरिक वृद्धि करते हैं अपवाद.

उदाहरण के लिए, यदि हमारे पास ए हाईस्ट्रिंग, हमारे पास Hy AST से Python तक की लगभग 1-टू-1 मैपिंग है
एएसटी. compile_string विधि लेता है हाईस्ट्रिंग, और एक लौटाता है ast.Str() है कि
सही पंक्ति-संख्याओं और सामग्री से भरा हुआ।

मैक्रो-विस्तार
यदि हमें ए हाईएक्सप्रेशन, हम यह देखने का प्रयास करेंगे कि क्या यह एक ज्ञात मैक्रो है, और इसे पाने के लिए प्रयास करेंगे
इसका आह्वान करके विस्तार किया गया hy.macros.macroexpand, फिर परिणाम को वापस धकेलें
HyASTकंपाइलर.संकलन.

दूसरा ट्रेनिंग अभिव्यक्ति-प्रेषण
एकमात्र विशेष मामला है हाईएक्सप्रेशन, चूँकि हमें अलग-अलग एएसटी बनाने की आवश्यकता है
प्रश्नगत विशेष प्रपत्र पर. उदाहरण के लिए, जब हम एक हिट करते हैं (अगर <strong>उद्देश्य</strong> <strong>उद्देश्य</strong> असत्य), हम
उत्पन्न करने की आवश्यकता है ast.अगर, और उप-नोड्स को ठीक से संकलित करें। यहीं पर @बिल्ड्स()
एक तर्क के रूप में एक स्ट्रिंग के साथ आता है।

के लिए compile_expression (जिसे एक के साथ परिभाषित किया गया है @बिल्ड्स(HyExpression)) भेज देंगे
पहले तर्क की स्ट्रिंग के आधार पर। यदि, किसी कारण से, पहला तर्क नहीं है
एक स्ट्रिंग, यह उस मामले को भी ठीक से संभाल लेगी (संभवतः एक बढ़ाकर)। अपवाद).

यदि स्ट्रिंग हाई को ज्ञात नहीं है, तो यह एक बनाने के लिए डिफ़ॉल्ट होगा ast.कॉल करें, जो प्रयास करेंगे
एक रनटाइम कॉल करें (पायथन में, कुछ इस तरह फू ()).

मुद्दे मारो साथ में अजगर एएसटी
पायथन एएसटी बढ़िया है; इसी ने हमें इतनी शक्तिशाली परियोजना लिखने में सक्षम बनाया है
पाइथॉन से बहुत अधिक संघर्ष किए बिना पाइथॉन। किसी भी चीज़ की तरह, हमें इसमें अपना उचित हिस्सा मिला है
मुद्दे, और यहां उन सामान्य मुद्दों की एक छोटी सूची दी गई है जिनका सामना आप कर सकते हैं।

अजगर differentiates के बीच वक्तव्य और एक्सप्रेशंस.

यह कोई बड़ी बात नहीं लग सकती है - वास्तव में, अधिकांश पायथन प्रोग्रामर के लिए, यह होगा
शीघ्र ही "ठीक है, हाँ" क्षण बन गया।

पायथन में, कुछ ऐसा कर रहे हैं:

छाप एसटी x in रेंज(10) पास, क्योंकि छाप भाव प्रिंट करता है, और एसटी एक नहीं है
अभिव्यक्ति, यह एक नियंत्रण प्रवाह कथन है। चीजें जैसे की 1 + 1 अभिव्यक्तियाँ हैं, जैसी हैं लैम्ब्डा
x: 1 + x, लेकिन अन्य भाषा सुविधाएँ, जैसे if, एसटी या, जब कथन हैं.

चूँकि उनके पास पायथन के लिए कोई "मूल्य" नहीं है, इससे कुछ करने के बाद से हाई में काम करना कठिन हो जाता है
पसंद (प्रिंट करें (अगर <strong>उद्देश्य</strong> <strong>उद्देश्य</strong> असत्य)) यह केवल सामान्य नहीं है, यह अपेक्षित है।

परिणामस्वरूप, हम a का उपयोग करके चीज़ों को स्वचालित रूप से व्यवस्थित करते हैं परिणाम वस्तु, जहां हम कोई पेशकश करते हैं ast.stmt
इसके लिए रन चाहिए और एक सिंगल ast.expr जिसका उपयोग किसी भी चीज़ का मूल्य प्राप्त करने के लिए किया जा सकता है
अभी चलाया गया था. हाई दौड़ते समय चीजों को जबरदस्ती असाइनमेंट देकर ऐसा करता है।

उदाहरण के तौर पर, हाई:

(प्रिंट करें (यदि सत्य है तो सत्य है असत्य))

में बदल जाएगा:

यदि सही:
_मंगल्ड_नाम_यहाँ = सत्य
अन्य:
_मंगल्ड_नाम_यहाँ = गलत

_मैंगल्ड_नाम_यहां प्रिंट करें

ठीक है, यह थोड़ा झूठ था, क्योंकि हम वास्तव में उस कथन को इसमें बदल देते हैं:

यदि सत्य है तो सत्य प्रिंट करें अन्यथा असत्य

चीजों को जबरदस्ती अंदर डालकर ast.expr यदि हम कर सकते हैं, लेकिन सामान्य विचार यही है।

कदम 4: अजगर बाईटकोड उत्पादन और क्रम
हमारे पास Python AST ट्री पूरा होने के बाद, हम इसे Python में संकलित करने का प्रयास कर सकते हैं
इसके माध्यम से धक्का देकर बाइटकोड विकसित करना. यहाँ से, अब हमारा नियंत्रण नहीं रहा, और
पाइथॉन हर चीज़ का ख्याल रख रहा है। यही कारण है कि पायथन ट्रेसबैक, पीडीबी और जैसी चीजें
django ऐप्स काम करते हैं।

Hy मैक्रोज़
का प्रयोग gensym एसटी सुरक्षित मैक्रोज़
मैक्रोज़ लिखते समय, बाहरी चर को कैप्चर करने या उपयोग करने से बचने के लिए सावधान रहना चाहिए
वेरिएबल नाम जो उपयोगकर्ता कोड के साथ विरोध कर सकते हैं।

हम एक उदाहरण मैक्रो का उपयोग करेंगे n यदि (देखें
http://letoverlambda.com/index.cl/guest/chap3.html#सेकंड_5 अधिक संपूर्ण विवरण के लिए।)
n यदि एक उदाहरण है, कुछ-कुछ संख्यात्मक जैसा if, जहां अभिव्यक्ति के आधार पर, में से एक
अभिव्यक्ति सकारात्मक, शून्य या नकारात्मक है या नहीं, इसके आधार पर 3 रूपों को बुलाया जाता है।

पहला पास कुछ इस प्रकार हो सकता है:

(डेफ़मैक्रो एनआईएफ [एक्सपीआर पॉज़-फॉर्म शून्य-फॉर्म नकारात्मक-फॉर्म]
`(चलो [[अस्पष्ट-नाम ~expr]]
(cond [(pos? अस्पष्ट-नाम) ~pos-form]
[(शून्य? अस्पष्ट-नाम) ~शून्य-रूप]
[(नकारात्मक? अस्पष्ट-नाम) ~नकारात्मक-रूप])))

जहां अस्पष्ट-नाम कुछ परिवर्तनीय नाम चुनने का प्रयास है ताकि दूसरे के साथ टकराव न हो
कोड. लेकिन निश्चित रूप से, नेक इरादे के बावजूद, इसकी कोई गारंटी नहीं है।

जेनसिम विधि को ऐसे अवसर के लिए एक नया, अद्वितीय प्रतीक उत्पन्न करने के लिए डिज़ाइन किया गया है।
का एक बहुत बेहतर संस्करण n यदि होने वाला:

(डेफ़मैक्रो एनआईएफ [एक्सपीआर पॉज़-फॉर्म शून्य-फॉर्म नकारात्मक-फॉर्म]
(चलिए [[g (gensym)]]
`(चलिए [[~g ~expr]]
(cond [(pos? ~g) ~pos-form]
[(शून्य? ~जी) ~शून्य-रूप]
[(नकारात्मक? ~जी) ~नकारात्मक रूप]))))

यह एक आसान मामला है, क्योंकि केवल एक ही प्रतीक है। लेकिन अगर कई की जरूरत है
gensym's में gensyms के साथ एक दूसरा मैक्रो है जो मूल रूप से एक श्रृंखला तक विस्तारित होता है चलो
बयान:

(साथ-जेनसिम्स [ए बी सी]
...)

इसका विस्तार होता है:

(चलिए [[a (gensym)
[बी (जेनसिम)
[सी (जेनसिम)]]
...)

तो हमारा दोबारा लिखा गया n यदि ऐसा दिखेगा:

(डेफ़मैक्रो एनआईएफ [एक्सपीआर पॉज़-फॉर्म शून्य-फॉर्म नकारात्मक-फॉर्म]
(साथ-जेनसिम्स [जी]
`(चलिए [[~g ~expr]]
(cond [(pos? ~g) ~pos-form]
[(शून्य? ~जी) ~शून्य-रूप]
[(नकारात्मक? ~जी) ~नकारात्मक रूप]))))

अंततः, यद्यपि हम एक नया मैक्रो बना सकते हैं जो हमारे लिए यह सब करता है। डेफ़मैक्रो/जी! लेगा
वे सभी प्रतीक जिनसे आरंभ होता है g! और स्वचालित रूप से कॉल करें gensym के शेष के साथ
प्रतीक। इसलिए जी!ए बन जाएगा (जेनसिम "ए").

हमारा अंतिम संस्करण n यदि, के साथ बनाया गया डेफ़मैक्रो/जी! हो जाता है:

(डेफ़मैक्रो/जी! एनआईएफ [एक्सपीआर पॉज़-फॉर्म शून्य-फॉर्म नकारात्मक-फॉर्म]
`(चलो [[~g!res ~expr]]
(cond [(pos? ~g!res) ~pos-form]
[(शून्य? ~g!res) ~शून्य-रूप]
[(नकारात्मक? ~g!res) ~नकारात्मक-रूप]))))

जाँच हो रही है मैक्रो तर्क और स्थापना अपवाद
Hy संकलक निर्मित इन्स

योगदान देने वाला मॉड्यूल सूचकांक

सामग्री:

अनाफोरिक मैक्रोज़
संस्करण 0.9.12 में नया।

एनाफोरिक मैक्रोज़ मॉड्यूल हाई में कार्यात्मक प्रोग्रामिंग को बहुत संक्षिप्त और आसान बनाता है
पढ़ें.
एनाफोरिक मैक्रो एक प्रकार का प्रोग्रामिंग मैक्रो है जो जानबूझकर किसी रूप को कैप्चर करता है
मैक्रो को आपूर्ति की जाती है जिसे एनाफोर (एक अभिव्यक्ति संदर्भित) द्वारा संदर्भित किया जा सकता है
दूसरे करने के लिए)। — विकिपीडिया (http://en.wikipedia.org/wiki/Anaphoric_macro)

मैक्रोज़
एपी-अगर
उपयोग: (एपी-अगर (फू) (प्रिंट करें यह))

सत्यता के लिए प्रथम रूप का मूल्यांकन करता है, और उससे बंधता है it सत्य और असत्य दोनों में
शाखाओं।

एक आड़ू
उपयोग: (एक आड़ू [1 2 3 4 5] (प्रिंट करें यह))

दुष्प्रभावों के लिए सूची में प्रत्येक तत्व के फॉर्म का मूल्यांकन करें।

एपी-प्रत्येक समय
उपयोग: (एपी-प्रत्येक-समय पर सूची से पहले तन)

प्रत्येक तत्व के लिए प्रपत्र का मूल्यांकन करें जहां विधेय प्रपत्र वापस आता है यह सच है.

=> (एपी-प्रत्येक-जबकि [1 2 3 4 5 6] (<यह 4) (इसे प्रिंट करें))
1
2
3

एपी-मैप
उपयोग: (एपी-मैप प्रपत्र सूची)

मानचित्र का एनाफोरिक रूप किसी फ़ंक्शन के बजाय नियमित मानचित्र की तरह ही काम करता है
वस्तु यह एक हाई रूप लेती है। विशेष नाम it से वर्तमान वस्तु से बंधा हुआ है
पुनरावृत्ति में सूची.

=> (सूची (एपी-मैप (* यह 2) [1 2 3]))
[2, 4, 6]

एपी-मैप-कब
उपयोग: (एपी-मैप-कब predfn प्रतिनिधि सूची)

कब लागू करना है यह निर्धारित करने के लिए एक विधेय फ़ंक्शन का उपयोग करके सूची पर मैपिंग का मूल्यांकन करें
प्रपत्र.

=> (सूची (एपी-मैप-कब विषम? (* यह 2) [1 2 3 4]))
[०, २, १, ०]

=> (सूची (एपी-मैप-कब सम? (* यह 2) [1 2 3 4]))
[०, २, १, ०]

एपी-फ़िल्टर
उपयोग: (एपी-फ़िल्टर प्रपत्र सूची)

साथ ही एपी-मैप हम तत्वों को फ़िल्टर करने के लिए किसी फ़ंक्शन के बजाय एक विशेष रूप लेते हैं
सूची। विशेष नाम it पुनरावृत्ति में वर्तमान तत्व से बंधा हुआ है।

=> (सूची (एपी-फ़िल्टर (> (* यह 2) 6) [1 2 3 4 5]))
[4, 5]

एपी-अस्वीकार
उपयोग: (एपी-अस्वीकार प्रपत्र सूची)

यह फ़ंक्शन इसके विपरीत कार्य करता है एपी-फ़िल्टर, यह गुजरने वाले तत्वों को अस्वीकार करता है
विधेय । विशेष नाम it पुनरावृत्ति में वर्तमान तत्व से बंधा हुआ है।

=> (सूची (एपी-अस्वीकार (> (* यह 2) 6) [1 2 3 4 5]))
[1, 2, 3]

एपी-डॉटाइम्स
प्रयोग (एपी-डोटाइम्स n तन)

यह फ़ंक्शन शरीर का मूल्यांकन करता है n समय, विशेष चर के साथ it से बाध्य 0 सेवा मेरे
1-एन. यह दुष्प्रभाव के लिए उपयोगी है।

=> (सेटव एन [])
=> (एपी-डोटाइम्स 3 (.इसे जोड़ें))
=> एन
[0, 1, 2]

एपी-प्रथम
प्रयोग (एपी-प्रथम predfn सूची)

यह फ़ंक्शन पहला तत्व लौटाता है जो विधेय या से गुजरता है कोई नहीं, के साथ
विशेष चर it पुनरावृत्ति में वर्तमान तत्व से बंधा हुआ।

=>(एपी-प्रथम (> यह 5) (रेंज 10))
6

एपी-अंतिम
प्रयोग (एपी-अंतिम) predfn सूची)

यह फ़ंक्शन अंतिम तत्व लौटाता है जो विधेय या से गुजरता है कोई नहीं, विशेष के साथ
परिवर्तनशील it पुनरावृत्ति में वर्तमान तत्व से बंधा हुआ।

=>(एपी-अंतिम (> यह 5) (श्रेणी 10))
9

एपी-कम करें
प्रयोग (एपी-कम करें प्रपत्र सूची &वैकल्पिक आरंभिक मूल्य)

यह फ़ंक्शन शरीर में पहले 2 तत्वों पर फॉर्म लागू करने का परिणाम लौटाता है
सूची समाप्त होने तक परिणाम और तीसरा तत्व आदि लागू करना। वैकल्पिक रूप से ए
प्रारंभिक मूल्य की आपूर्ति की जा सकती है इसलिए फ़ंक्शन को प्रारंभिक मूल्य पर लागू किया जाएगा
इसके बजाय पहला तत्व। यह उस तत्व को उजागर करता है जिसे इस रूप में दोहराया जा रहा है it और वर्तमान
संचित मूल्य के रूप में एसीसी.

=>(एपी-रिड्यूस (+ आईटी एसीसी) (रेंज 10))
45

लूप/पुनरावृत्ति
संस्करण 0.10.0 में नया।

RSI पाश / पुनरावृत्ति होना मैक्रो प्रोग्रामर्स को टेल-कॉल ऑप्टिमाइज़ेशन (टीसीओ) का उपयोग करने का एक आसान तरीका देता है
उनके हाई कोड में.
टेल कॉल एक सबरूटीन कॉल है जो किसी अन्य प्रक्रिया के अंतिम रूप में होती है
कार्रवाई; यह एक रिटर्न वैल्यू उत्पन्न कर सकता है जिसे कॉलिंग द्वारा तुरंत वापस कर दिया जाता है
प्रक्रिया। यदि कोई कॉल जो सबरूटीन निष्पादित करता है, जैसे कि यह अंततः नेतृत्व कर सकता है
इसी सबरूटीन को कॉल श्रृंखला के नीचे फिर से कॉल किया जा रहा है, यह टेल स्थिति में है,
ऐसे सबरूटीन को टेल-रिकर्सिव कहा जाता है, जो रिकर्सन का एक विशेष मामला है।
टेल कॉल महत्वपूर्ण हैं क्योंकि उन्हें नया स्टैक जोड़े बिना लागू किया जा सकता है
कॉल स्टैक के लिए फ्रेम। वर्तमान प्रक्रिया के अधिकांश फ्रेम की कोई आवश्यकता नहीं है
अधिक, और इसे टेल कॉल के फ्रेम द्वारा प्रतिस्थापित किया जा सकता है। प्रोग्राम तब जंप कर सकता है
बुलाए गए सबरूटीन के लिए। मानक कॉल अनुक्रम के बजाय ऐसे कोड का उत्पादन करना है
टेल कॉल एलिमिनेशन, या टेल कॉल ऑप्टिमाइज़ेशन कहा जाता है। टेल कॉल उन्मूलन की अनुमति देता है
टेल पोजीशन में प्रक्रिया कॉल को गोटो स्टेटमेंट के समान कुशलतापूर्वक लागू किया जाना चाहिए,
इस प्रकार कुशल संरचित प्रोग्रामिंग की अनुमति मिलती है। — विकिपीडिया (-
http://en.wikipedia.org/wiki/Tail_call)

मैक्रोज़
पाश
पाश एक पुनरावर्तन बिंदु स्थापित करता है। साथ पाश, पुनरावृत्ति होना में सेट किए गए वेरिएबल्स को दोबारा जोड़ता है
रिकर्सन बिंदु और कोड निष्पादन को उस रिकर्सन बिंदु पर वापस भेजता है। अगर पुनरावृत्ति होना में प्रयोग किया जाता है
एक गैर-पूंछ स्थिति, एक अपवाद फेंक दिया जाता है।

उपयोग: (कुंडली बाइंडिंग &आराम तन)

उदाहरण:

(hy.contrib.loop की आवश्यकता है)

(defn भाज्य [n]
(लूप [[i n] [एसीसी 1]]
(यदि (शून्य? i)
एसीसी
(पुनरावृत्ति (दिसम्बर i) (* एसीसी i)))))

(फैक्टोरियल 1000)

defmulti
संस्करण 0.10.0 में नया।

defmulti आपको किसी फ़ंक्शन को दिए गए args और/या kwargs की संख्या से ओवरलोड करने की सुविधा देता है।
क्लोजर के दृष्टिकोण से प्रेरित होकर रक्षा.

=> (hy.contrib.multi की आवश्यकता है)
=> (डेफ़मल्टी मज़ेदार
... ([ए] "ए")
... ([ए बी] "ए बी")
... ([ए बी सी] "ए बी सी"))
=> (मज़ा 1)
"ए"
=> (मज़ा 1 2)
"ए बी"
=> (मज़ा 1 2 3)
"ए बी सी"

हैकिंग ON HY

जुडें हमारी हाईवे!
कृपया हाई पर हैक करें!

कृपया हमारे साथ घूमने आएं #हाय on irc.freenode.net!

कृपया इसके बारे में ट्विटर पर बात करें #हाय हैशटैग!

कृपया इसके बारे में ब्लॉग करें!

कृपया इसे अपने पड़ोसी की बाड़ पर स्प्रे-पेंट न करें (अच्छी तरह से पूछे बिना)!

हैक!
यह करो:

1। बनाओ आभासी वातावरण:

$ वर्चुअलएन्व वेनव

और इसे सक्रिय करें:

$ . वेनव/बिन/सक्रिय करें

या उपयोग करें वर्चुअलएन्व्रैपर अपना आभासी वातावरण बनाने और प्रबंधित करने के लिए:

$ mkvirtualenv हाय
$ वर्कऑन हाई

2. स्रोत कोड प्राप्त करें:

$ गिट क्लोन https://github.com/hylang/hy.git

या अपने कांटे का उपयोग करें:

$ git क्लोन [ईमेल संरक्षित]:/hy.git

3. हैकिंग के लिए इंस्टॉल करें:

$ सीडी हाई/
$ पिप इंस्टाल -ई।

4. अन्य विकास-वाई आवश्यकताएँ स्थापित करें:

$ पिप इंस्टाल -आर आवश्यकताएँ-dev.txt

5. अद्भुत कार्य करो; आपने जो किया है उस पर किसी को ख़ुशी/नाराजगी से चिल्लाना।

टेस्ट!
परीक्षण स्थित हैं परीक्षण /। हम प्रयोग करते हैं नाक.

परीक्षण चलाने के लिए:

$ नोज़टेस्ट

परीक्षण लिखें---परीक्षण अच्छे हैं!

इसके अलावा, समर्थित सभी प्लेटफार्मों और पीईपी 8 के अनुरूप परीक्षणों को चलाना अच्छा है
कोड. आप टॉक्स चलाकर ऐसा कर सकते हैं:

$ टॉक्स

दस्तावेज़!
दस्तावेज़ीकरण स्थित है डॉक्स /। हम प्रयोग करते हैं गूढ़ व्यक्ति.

HTML में दस्तावेज़ बनाने के लिए:

$ सीडी दस्तावेज़
$ एचटीएमएल बनाओ

दस्तावेज़ लिखें--- दस्तावेज़ अच्छे हैं! यहाँ तक कि यह दस्तावेज़ भी!

योगदान
योगदान का स्वागत है और इसकी बहुत सराहना की जाती है, हर छोटा सा योगदान हाई को और अधिक बेहतर बनाने में मदद करता है
बहुत बढ़िया।

खींचने के अनुरोध बढ़िया हैं! हम उन्हें प्यार करते हैं; यहाँ एक त्वरित मार्गदर्शिका है:

· रेपो को फोर्क करें और किसी फीचर/फिक्स के लिए एक विषय शाखा बनाएं। सीधे परिवर्तन करने से बचें
मास्टर शाखा पर.

· आने वाली सभी सुविधाओं के साथ परीक्षण भी होना चाहिए।

· पीआर सबमिट करने से पहले, कृपया परीक्षण चलाएं और शैली के अनुसार अपना कोड जांचें
मार्गदर्शक। आप ये दोनों काम एक साथ कर सकते हैं:

$ बनाओ डी

· कमिट को तार्किक इकाइयों में बनाएं, ताकि बाद में ट्रैक करना और नेविगेट करना आसान हो। पहले
पीआर सबमिट करते समय, कमिट को उन बदलावों में विभाजित करने का प्रयास करें जिन पर वापस आना आसान हो
बाद में। साथ ही, सुनिश्चित करें कि आप परिवर्तनसेट में नकली रिक्त स्थान न छोड़ें; यह
बाद में व्हाइटस्पेस फिक्स कमिट बनाने से बचा जाता है।

· जहां तक ​​प्रतिबद्ध संदेशों की बात है, निम्नलिखित का पालन करने का प्रयास करें:

· Git प्रतिबद्ध संदेशों की पहली पंक्ति के लिए 50 वर्ण सीमा का पालन करने का प्रयास करें।

· अधिक विवरण/स्पष्टीकरण के लिए, इसके बाद एक रिक्त पंक्ति लिखें और जारी रखें
प्रतिबद्धता का विस्तार से वर्णन करना।

· अंत में, अपने आप को लेखक फ़ाइल में जोड़ें (एक अलग प्रतिबद्धता के रूप में): आप इसके लायक हैं :)

· आने वाले सभी परिवर्तनों को हिलैंग की कोर टीम के 2 अलग-अलग सदस्यों द्वारा स्वीकार किया जाना चाहिए।
अतिरिक्त समीक्षा का स्पष्ट रूप से स्वागत है, लेकिन हमें किसी के लिए भी कम से कम 2 साइनऑफ़ की आवश्यकता है
बदल जाते हैं.

· यदि कोई मुख्य सदस्य पीआर भेज रहा है, तो कृपया 2 मुख्य सदस्य खोजें जिनमें ये शामिल नहीं हैं
पीआर प्रस्तुतकर्ता. यहां विचार यह है कि एक पीआर लेखक के साथ काम कर सकता है, और दूसरा एसीएस के साथ
संपूर्ण परिवर्तन सेट.

· दस्तावेज़ीकरण और अन्य छोटे-मोटे बदलावों के लिए, हम एक ACK के बाद विलय करने के लिए तैयार हैं। हमें मिल गया है
कम कवरेज, इसलिए उस बाधा को कम रखना बहुत अच्छा होगा।

मूल टीम
Hy की मुख्य विकास टीम में निम्नलिखित डेवलपर्स शामिल हैं:

· जुलिएन Danjou

· मोर्टेन लिंडरुड

· J केनेथ राजा

· गेर्गेले नागी

· तुउक्का टरटो

· करेन रुस्तद

· अभिषेक L

· क्रिस्टोफर एलन वेबर

· कोनराड हिंसन

· विल काह्न-ग्रीन

· पॉल टैग्लियामोंटे

· निकोलस डैंड्रिमोंट

· बॉब टॉल्बर्ट

· Berker पेक्साग

· क्लिंटन N. ड्रेइस्बैक

· वह Semaj

onworks.net सेवाओं का उपयोग करके ऑनलाइन हाय का उपयोग करें