hy - ออนไลน์ในคลาวด์

โครงการ:

ชื่อ

hy - hy เอกสาร [ภาพ: Hy] [ภาพ]

ดู Hy https://try-hy.appspot.com

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

แหล่ง https://github.com/hylang/hy

รายการ อภิปราย-อภิปราย

ไออาร์ซี #เฮีย บน Freenode

สร้าง สถานะ
เทรวิส CI. ไม่ระบุ

Hy เป็นภาษาถิ่นที่ยอดเยี่ยมของ Lisp ที่ฝังอยู่ใน Python

เนื่องจาก Hy แปลงรหัส Lisp เป็น Python Abstract Syntax Tree คุณจึงมี
โลกที่สวยงามทั้งใบของ Python เพียงปลายนิ้วสัมผัส ในรูปแบบ Lisp!

เนื้อหา:

เริ่มต้นอย่างรวดเร็ว

[ภาพ: การกอดของชาวกะเหรี่ยง Rustard] [ภาพ]

(ขอบคุณ Karen Rustad สำหรับการกอด!)

วิธีการ TO GET HY REAL FAST:

1 สร้าง a เสมือน หลาม สิ่งแวดล้อม.

2. เปิดใช้งาน Virtual Python Environment ของคุณ

3 ติดตั้ง hy ราคาเริ่มต้นที่ PyPI กับ จุดเล็ก ๆ ติดตั้ง hy.

4. เริ่ม REPL ด้วย hy.

5. พิมพ์สิ่งต่าง ๆ ใน REPL:

=> (พิมพ์ "เฮ้!")
Hy!
=> (defn salutationsnm [ชื่อ] (พิมพ์ (+ "Hy " ชื่อ "!")))
=> (คำทักทาย "ชื่อคุณ")
เฮ้ ชื่อของคุณ!

ฯลฯ

6. กด CTRL-D เมื่อเสร็จแล้ว

OMG! ที่ น่าทึ่ง! I ต้องการ ไปยัง เขียน a Hy โครงการ

7. เปิดตัวแก้ไขโปรแกรมยอดเยี่ยมและพิมพ์:

(พิมพ์ "ฉันกำลังจะเขียนโค้ดในไวยากรณ์ Python แต่แล้วฉันก็ได้ Hy")

8. บันทึกเป็น น่ากลัว.

9. และรันโปรแกรม Hy แรกของคุณ:

hy น่ากลัว hy

10.
หายใจเข้าลึก ๆ เพื่อไม่ให้หายใจไม่ออก

11.
ยิ้มอย่างชั่วร้ายแล้วแอบไปที่ไฮด์อเวย์ของคุณและทำสิ่งที่พูดไม่ได้

การสอน

ยินดีต้อนรับสู่กวดวิชา Hy!

โดยสรุป Hy เป็นภาษา Lisp แต่เป็นภาษาที่แปลงโครงสร้างเป็น Python ...
แท้จริงการแปลงเป็นแผนผังไวยากรณ์นามธรรมของ Python! (หรือจะใส่หยาบกว่านี้ก็ได้
เงื่อนไข Hy คือ lisp-stick บน Python!)

มันค่อนข้างเจ๋งเพราะมันหมายความว่า Hy มีหลายสิ่ง:

· เสียงกระเพื่อมที่ให้ความรู้สึกงูหลามมาก

· สำหรับ Lispers วิธีที่ยอดเยี่ยมในการใช้พลังที่บ้าคลั่งของ Lisp แต่ในโลกอันกว้างใหญ่ของ Python
ไลบรารี่ (ใช่แล้ว ตอนนี้คุณสามารถเขียนแอปพลิเคชัน Django ใน Lisp ได้แล้ว!)

· สำหรับ Pythonistas วิธีที่ยอดเยี่ยมในการเริ่มต้นสำรวจ Lisp จากความสะดวกสบายของ Python!

· สำหรับทุกคน: ภาษาที่สบายตาและมีไอเดียเจ๋งๆ มากมาย!

ขั้นพื้นฐาน อินโทร ไปยัง เสียงกระเพื่อม for ไพธอนนิสต้า
โอเค บางทีคุณอาจไม่เคยใช้ Lisp มาก่อน แต่คุณเคยใช้ Python!

โปรแกรม "สวัสดีชาวโลก" ใน Hy นั้นเรียบง่ายจริงๆ มาลองดูกัน:

(พิมพ์ "สวัสดีชาวโลก")

ดู? ง่าย! อย่างที่คุณอาจเดาได้ สิ่งนี้เหมือนกับเวอร์ชัน Python ของ:

พิมพ์ "สวัสดีชาวโลก"

ในการบวกเลขคณิตง่ายๆ เราทำได้ดังนี้

(+ 1 3)

ซึ่งจะคืนค่า 4 และจะเทียบเท่ากับ:

1 + 3

สิ่งที่คุณจะสังเกตเห็นคือรายการแรกในรายการคือฟังก์ชันที่ถูกเรียกใช้และ
อาร์กิวเมนต์ที่เหลือเป็นข้อโต้แย้งที่ถูกส่งผ่าน อันที่จริงใน Hy (เช่นเดียวกับส่วนใหญ่
เสียงกระเพื่อม) เราสามารถส่งต่อหลายอาร์กิวเมนต์ไปยังตัวดำเนินการ plus:

(+1 3 55)

ซึ่งจะส่งคืน 59

คุณอาจเคยได้ยินชื่อ Lisp มาก่อนแต่ไม่ค่อยรู้เรื่องนี้มากนัก ฟินได้ไม่ยากเท่าคุณ
อาจคิดได้ และ Hy สืบทอดมาจาก Python ดังนั้น Hy เป็นวิธีที่ยอดเยี่ยมในการเริ่มต้นเรียนรู้ Lisp
สิ่งสำคัญที่ชัดเจนเกี่ยวกับ Lisp คือมีวงเล็บจำนวนมาก นี้อาจจะ
ดูเหมือนสับสนในตอนแรก แต่ก็ไม่ได้ยากนัก มาดูคณิตศาสตร์ง่ายๆ กันที่
ในวงเล็บที่เราใส่เข้าไปในล่าม Hy ได้

(ผลลัพธ์ setv (- (/ (+ 1 3 88) 2) 8))

สิ่งนี้จะส่งกลับ 38 แต่ทำไม? เราสามารถดูที่นิพจน์เทียบเท่าใน
หลาม:

ผลลัพธ์ = ((1 + 3 + 88) / 2) - 8

ถ้าคุณต้องพยายามคิดให้ออกว่าวิธีข้างต้นทำงานอย่างไรใน python แน่นอน
หาผลลัพธ์โดยการแก้วงเล็บในแต่ละตัว นั่นเป็นแนวคิดพื้นฐานเดียวกันใน
ไฮ. ลองทำแบบฝึกหัดนี้ก่อนใน Python:

ผลลัพธ์ = ((1 + 3 + 88) / 2) - 8
#เรียบง่ายเพื่อ...
ผลลัพธ์ = (92 / 2) - 8
#เรียบง่ายเพื่อ...
ผลลัพธ์ = 46 - 8
#เรียบง่ายเพื่อ...
ผลลัพธ์ = 38

ทีนี้มาลองทำสิ่งเดียวกันใน Hy:

(ผลลัพธ์ setv (- (/ (+ 1 3 88) 2) 8))
; ง่ายที่จะ...
(ผลลัพธ์ setv (- (/ 92 2) 8))
; ง่ายที่จะ...
(ผลลัพธ์ setv (- 46 8))
; ง่ายที่จะ...
(ผลลัพธ์ setv 38)

อย่างที่คุณอาจเดาได้ว่า นิพจน์สุดท้ายนี้กับ เซ็ตทีวี หมายถึงการกำหนดตัวแปร
"ผลลัพธ์" ถึง 38

ดู? ไม่ยากเกินไป!

นี่คือพื้นฐานของ Lisp Lisp ย่อมาจาก "การประมวลผลรายการ"; นี่หมายความว่า
โครงสร้างของโปรแกรมเป็นรายการของรายการจริง (ถ้าคุณคุ้นเคยกับ Python
รายการ ลองนึกภาพโครงสร้างเดียวกันทั้งหมดข้างต้น แต่มีวงเล็บเหลี่ยมแทน any
คุณจะเห็นโครงสร้างด้านบนเป็นทั้งโปรแกรมและโครงสร้างข้อมูล) นี่คือ
เข้าใจง่ายขึ้นพร้อมตัวอย่างเพิ่มเติม เลยลองเขียนโปรแกรม Python ง่ายๆ ทดสอบดู
แล้วแสดงโปรแกรม Hy ที่เทียบเท่า:

def simple_conversation ():
พิมพ์ "สวัสดี ฉันอยากรู้จักคุณ บอกฉันเกี่ยวกับตัวคุณหน่อย!"
name = raw_input("คุณชื่ออะไร")
อายุ = raw_input("คุณอายุเท่าไหร่")
พิมพ์ "สวัสดี " + ชื่อ + " ฉันเห็นคุณ " + อายุ + " ปีแล้ว "

Simple_conversation()

ถ้าเรารันโปรแกรมนี้ มันอาจจะไปเช่น:

สวัสดี! ฉันอยากรู้จักคุณ บอกฉันเกี่ยวกับตัวคุณ!
คุณชื่ออะไร? แกรี่
คุณอายุเท่าไหร่? 38
สวัสดีแกรี่! ฉันเห็นคุณอายุ 38 ปี

ทีนี้มาดูที่โปรแกรม Hy ที่เทียบเท่ากัน:

(defn บทสนทนาง่าย ๆ []
(พิมพ์ "สวัสดี! ฉันอยากรู้จักคุณ บอกฉันเกี่ยวกับตัวคุณ!")
(ชื่อ setv (อินพุตแบบดิบ "คุณชื่ออะไร"))
(อายุ setv (อินพุตแบบดิบ "คุณอายุเท่าไหร่"))
(พิมพ์ (+ "สวัสดี " ชื่อ "! ฉันเห็นคุณเป็น"
อายุ " ปี.")))

(บทสนทนาง่ายๆ)

หากดูจากโปรแกรมข้างต้น ตราบใดที่ยังจำองค์ประกอบแรกในแต่ละส่วนได้
รายการของโปรแกรมคือฟังก์ชั่น (หรือมาโคร... เราจะพูดถึงในภายหลัง) ที่เรียกว่า
และที่เหลือเป็นข้อโต้แย้ง มันค่อนข้างง่ายที่จะเข้าใจว่าทั้งหมดนี้หมายความว่าอย่างไร
(อย่างที่คุณอาจเดาได้ ป้องกัน คือวิธี Hy กำหนดวิธีการ)

ถึงกระนั้น หลายคนก็ยังรู้สึกสับสนในตอนแรก เพราะมีวงเล็บหลายอัน
แต่มีหลายอย่างที่ช่วยให้สิ่งนี้ง่ายขึ้น: เยื้องให้ดีและ
ใช้ตัวแก้ไขที่มีวงเล็บตรงกัน (ซึ่งจะช่วยให้คุณทราบได้ว่าแต่ละข้อคืออะไร
วงเล็บจับคู่กับ) และสิ่งต่างๆ จะเริ่มรู้สึกสบายตัว

มีข้อดีบางประการในการมีโครงสร้างโค้ดที่เป็นข้อมูลที่เรียบง่ายจริงๆ
โครงสร้างที่เป็นแก่นของเสียงกระเพื่อมจะขึ้นอยู่กับ ประการหนึ่ง หมายความว่าโปรแกรมของคุณคือ
แยกวิเคราะห์ได้ง่ายและโครงสร้างจริงทั้งหมดของโปรแกรมถูกเปิดเผยอย่างชัดเจน
ถึงคุณ. (มีขั้นตอนเพิ่มเติมใน hy โดยที่โครงสร้างที่คุณเห็นถูกแปลงเป็น Python's
การแสดงแทนตนเอง ... ใน Lisp "ที่บริสุทธิ์กว่า" เช่น Common Lisp หรือ Emacs Lisp, data
โครงสร้างที่คุณเห็นในโค้ดและโครงสร้างข้อมูลที่ดำเนินการมีมากขึ้น
ใกล้อย่างแท้จริง)

ความหมายอีกอย่างของสิ่งนี้คือมาโคร: ถ้าโครงสร้างของโปรแกรมเป็น data อย่างง่าย
โครงสร้างนั้นหมายความว่าคุณสามารถเขียนโค้ดที่สามารถเขียนโค้ดได้ง่ายมาก หมายความว่า
การใช้คุณลักษณะภาษาใหม่ทั้งหมดสามารถทำได้อย่างรวดเร็ว ก่อนหน้า Hy นี่ไม่ใช่
เป็นไปได้มากสำหรับโปรแกรมเมอร์ Python ... ตอนนี้คุณก็สามารถใช้มาโครได้อย่างไม่น่าเชื่อ
พลัง (ระวังอย่าเล็งไปทางเท้า)!

Hy is a รสลิ้นจี่ หลาม
Hy แปลงเป็นแผนผังโครงสร้างนามธรรมของ Python ดังนั้นคุณจะพบทั้งหมดในไม่ช้า
พลังที่คุ้นเคยของ python อยู่ที่ปลายนิ้วของคุณ

คุณสามารถเข้าถึงประเภทข้อมูลและไลบรารีมาตรฐานของ Python ได้อย่างเต็มที่ใน Hy มาทดลองกัน
ด้วยสิ่งนี้ในล่าม hy:

=> [1 2 3]
[1, 2, 3]
=> {"หมา" "เห่า"
... "แมว" "เหมียว"}
...
{'dog': 'bark', 'cat': 'meow'}
=> (, 1 2 3)
(1, 2, 3)

หากคุณคุ้นเคยกับ Lisps อื่น ๆ คุณอาจสนใจที่ Hy สนับสนุน Common
วิธีการพูดกระเพื่อม:

=> '(1 2 3)
(1ลิตร 2ลิตร 3ลิตร)

คุณยังสามารถเข้าถึงวิธีการที่ดีในตัวทั้งหมดได้:

=> (.strip " fooooo ")
"ฟู่ววว"

นี่อะไรน่ะ? ใช่แล้ว นี่เป็นสิ่งเดียวกันกับ:

" fooooo ". แถบ ()

ใช่แล้ว---เสียงกระเพื่อมด้วยเครื่องหมายจุด! ถ้าเรากำหนดสตริงนี้เป็นตัวแปร เรา
สามารถทำสิ่งต่อไปนี้ได้เช่นกัน:

(setv สตริงนี้ " fooooo ")
(นี่-สตริง.สตริป)

แล้วเงื่อนไขล่ะ?:

(ถ้า (ลองของบางอย่าง)
(พิมพ์ว่า "ถ้าเป็นจริง")
(พิมพ์ "นี่คือถ้าเป็นเท็จ"))

ดังที่คุณบอกได้ข้างต้น อาร์กิวเมนต์แรกของ if คือการทดสอบความจริง อาร์กิวเมนต์ที่สองคือ
เนื้อความถ้าเป็นจริงและอาร์กิวเมนต์ที่สาม (เป็นทางเลือก!) เป็นเท็จ (เช่น อื่น).

หากคุณต้องการทำเงื่อนไขที่ซับซ้อนกว่านี้ คุณจะพบว่าไม่มี elif
มีอยู่ใน Hy คุณควรใช้สิ่งที่เรียกว่า .แทน เงื่อนไข. ใน Python คุณอาจทำ
สิ่งที่ต้องการ:

ซัมวาร์ = 33
ถ้าบางครั้ง> 50:
พิมพ์ "ตัวแปรนั้นใหญ่เกินไป!"
เอลฟ์ซัมแวร์ < 10:
พิมพ์ "ตัวแปรนั้นเล็กเกินไป!"
อื่น:
พิมพ์ "ตัวแปรนั้นถูกต้องแล้ว!"

ใน Hy คุณจะทำ:

(คอนโด
[(> บ้าง 50)
(พิมพ์ "ตัวแปรนั้นใหญ่เกินไป!")]
[(< บางอย่าง 10)
(พิมพ์ "ตัวแปรนั้นเล็กเกินไป!")]
[จริง
(พิมพ์ "ตัวแปรนั้นถูกต้อง!")])

สิ่งที่จะสังเกตได้ก็คือ เงื่อนไข ปิดระหว่างคำสั่งบางคำสั่งที่ดำเนินการและ
ตรวจสอบตามเงื่อนไขว่าจริงหรือเท็จ จากนั้นจึงเรียกใช้โค้ดเล็กน้อยหากเปลี่ยนเป็น
ออกมาให้เป็นจริง คุณจะสังเกตเห็นว่า อื่น ถูกนำไปใช้ในตอนท้ายง่ายๆโดย
กำลังตรวจสอบ จริง -- นั่นเป็นเพราะ จริง จะเป็นจริงเสมอ ดังนั้นหากเรามาไกลขนาดนี้ เราจะ
เรียกใช้อันนั้นเสมอ!

คุณอาจสังเกตเห็นข้างต้นว่าถ้าคุณมีรหัสเช่น:

(ถ้าเงื่อนไขบางอย่าง
(ร่างกาย-ถ้า-จริง)
(ตัว-ถ้า-เท็จ))

แต่เดี๋ยวก่อน! เกิดอะไรขึ้นถ้าคุณต้องการดำเนินการมากกว่าหนึ่งคำสั่งในร่างกายของหนึ่งใน
เหล่านี้?

คุณสามารถทำสิ่งต่อไปนี้:

(ถ้า (ลองของบางอย่าง)
(เนื่องจาก
(พิมพ์ว่า "ถ้าเป็นจริง")
(พิมพ์ "แล้วมาเล่าต่อว่าจริงเท็จแค่ไหน!))
(พิมพ์ว่า "อันนี้ยังเป็นแค่เท็จ"))

จะเห็นว่าเราใช้ do เพื่อห่อหลายคำสั่ง หากคุณคุ้นเคยกับคนอื่น ๆ
Lisps นี่เทียบเท่ากับ การคาดการณ์ ที่อื่น ๆ

ความคิดเห็นเริ่มต้นด้วยเครื่องหมายอัฒภาค:

(พิมพ์ "สิ่งนี้จะทำงาน")
; (พิมพ์ "แต่สิ่งนี้จะไม่")
(+ 1 2 3) ; เราจะดำเนินการเพิ่มเติม แต่ไม่ใช่ความคิดเห็นนี้!

การวนลูปไม่ใช่เรื่องยาก แต่มีโครงสร้างพิเศษ ใน Python เราอาจทำ:

สำหรับฉันใน พิสัย(10):
พิมพ์ "'i' อยู่ที่ " + str(i)

เทียบเท่าใน Hy จะเป็น:

(สำหรับ [i (ช่วง 10)]
(พิมพ์ (+ "'i' อยู่ที่ " (str i))))

คุณยังสามารถนำเข้าและใช้งานไลบรารี Python ต่างๆ ได้ ตัวอย่างเช่น:

(ระบบปฏิบัติการนำเข้า)

(ถ้า (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/anotherdir")
(พิมพ์ "เฮ้ เส้นทางนั้นไม่มี!"))

ตัวจัดการบริบทของ Python (กับ คำสั่ง) ใช้ดังนี้:

(ด้วย [[f (เปิด "/tmp/data.in")]]
(พิมพ์ (.read f)))

ซึ่งเทียบเท่ากับ:

ด้วย open("/tmp/data.in") เป็น f:
พิมพ์ f.read()

ใช่แล้ว เรามี List Comprehensions! ใน Python คุณอาจทำ:

อัตราต่อรอง_กำลังสอง = [
แป้ง(น้ำ 2)
สำหรับจำนวนใน พิสัย(100)
ถ้าจำนวน % 2 == 1]

ใน Hy คุณสามารถทำสิ่งเหล่านี้ได้:

(setv อัตราต่อรอง-กำลังสอง
(list-com
(พาวหมายเลข 2)
(จำนวน (ช่วง 100))
(= (% จำนวน 2) 1)))

; และตัวอย่างที่ถูกขโมยอย่างไร้ยางอายจากหน้า Clojure:
; มาลิสต์บล็อคทั้งหมดของกระดานหมากรุกกัน:

(list-com
(, xy)
(x (ช่วง 8)
y "ABCDEFGH"))

; [(0, 'A'), (0, 'B'), (0, 'C'), (0, 'D'), (0, 'E'), (0, 'F'), ( 0, 'G'), (0, 'H'),
; (1, 'A'), (1 'B'), (1 'C'), (1 'D'), (1 'E'), (1 'F'), (1 , 'G'), (1, 'H'),
; (2, 'A'), (2 'B'), (2 'C'), (2 'D'), (2 'E'), (2 'F'), (2 , 'G'), (2, 'H'),
; (3, 'A'), (3 'B'), (3 'C'), (3 'D'), (3 'E'), (3 'F'), (3 , 'G'), (3, 'H'),
; (4, 'A'), (4 'B'), (4 'C'), (4 'D'), (4 'E'), (4 'F'), (4 , 'G'), (4, 'H'),
; (5, 'A'), (5 'B'), (5 'C'), (5 'D'), (5 'E'), (5 'F'), (5 , 'G'), (5, 'H'),
; (6, 'A'), (6 'B'), (6 'C'), (6 'D'), (6 'E'), (6 'F'), (6 , 'G'), (6, 'H'),
; (7, 'A'), (7, 'B'), (7, 'C'), (7, 'D'), (7, 'E'), (7, 'F'), (7 , 'G'), (7, 'H')]

Python รองรับอาร์กิวเมนต์แฟนซีและคีย์เวิร์ดที่หลากหลาย ใน Python เราอาจ
ดู:

>>> def optional_arg(pos1, pos2, คีย์เวิร์ด1=ไม่มี, คีย์เวิร์ด2=42):
... ส่งคืน [pos1, pos2, คำสำคัญ1, คำสำคัญ2]
...
>>> optional_arg(1, 2)
[1, 2, ไม่มี, 42]
>>> optional_arg (1, 2, 3, 4)
[1, 2, 3, 4]
>>> optional_arg(คีย์เวิร์ด1=1, pos2=2, pos1=3, คีย์เวิร์ด2=4)
[3, 2, 1, 4]

สิ่งเดียวกันใน Hy:

=> (defn optional-arg [pos1 pos2 & ทางเลือกคีย์เวิร์ด1 [keyword2 42]]
... [คีย์เวิร์ด pos1 pos2 1 คีย์เวิร์ด2])
=> (ตัวเลือก-arg 1 2)
[1 2 ไม่มี 42]
=> (ตัวเลือก-arg 1 2 3 4)
[1 2 3 4]

หากคุณใช้ Hy เวอร์ชันที่ผ่านมา 0.10.1 (เช่น git master) ก็ยังมีฟีเจอร์ใหม่ที่ดีอีกด้วย
ไวยากรณ์อาร์กิวเมนต์ของคีย์เวิร์ด:

=> (ตัวเลือก arg :keyword1 1
... :pos2 2
... :pos1 3
... :keyword2 4)
[3, 2, 1, 4]

มิเช่นนั้นก็ใช้ได้ตลอด ใช้. แต่มันคืออะไร ใช้?

คุณคุ้นเคยกับการผ่านเข้า * หาเรื่อง และ **ก๊วก. ใน Python?:

>>> หาเรื่อง = [1 2]
>>> kwargs = {"keyword2": 3
... "คำสำคัญ1": 4}
>>> optional_arg(*args, **kwargs)

เราสามารถทำซ้ำสิ่งนี้ได้ด้วย ใช้:

=> (setv args [1 2])
=> (setv kwargs {"keyword2" 3
... "คำสำคัญ1" 4})
=> (ใช้ตัวเลือก arg args kwargs)
[1, 2, 4, 3]

นอกจากนี้ยังมีการสร้างอาร์กิวเมนต์คำหลักสไตล์พจนานุกรมที่มีลักษณะดังนี้:

(กำหนดรูปแบบอื่น [&key {"key1" "val1" "key2" "val2"}]
[คีย์1คีย์2])

ความแตกต่างที่นี่คือเนื่องจากเป็นพจนานุกรม คุณจึงไม่สามารถพึ่งพาเฉพาะเจาะจงใดๆ ได้
สั่งให้โต้แย้ง

Hy ยังสนับสนุน * หาเรื่อง และ **ก๊วก.. ในไพทอน:

def some_func(foo, bar, *args, **kwargs):
นำเข้า pprint
pprint.pprint((ฟู บาร์ หาเรื่อง kwargs))

Hy เทียบเท่า:

(defn some-func [foo bar &rest args &kwargs kwargs]
(พิมพ์นำเข้า)
(pprint.pprint (, ฟู บาร์ หาเรื่อง kwargs)))

ในที่สุด เราก็ต้องมีคลาส! ใน Python เราอาจมีคลาสเช่น:

คลาส FooBar (วัตถุ):
"" "
อีกตัวอย่างหนึ่งคลาส
"" "
def __init__(ตัวเอง, x):
ตัวเอง x = x

def get_x (ตัวเอง):
"" "
ส่งคืนสำเนา x . ของเรา
"" "
กลับตัวเองx

ใน Hy:

(defclass FooBar [วัตถุ]
"ยังอีกชั้นตัวอย่าง"
[[--ในนั้น--
(fn [ตัวเอง x]
(setv self.xx)
; จำเป็นสำหรับ --init-- เนื่องจาก __init__ ต้องการ None
; หวังว่าสิ่งนี้จะหายไป :)
ไม่มี)]

[รับ-x
(fn [ตัวเอง]
"ส่งคืนสำเนา x ของเรา"
ตัวเอง.x)]])

คุณยังสามารถทำแอตทริบิวต์ระดับคลาสได้ ในไพทอน:

คลาสลูกค้า (models.Model):
ชื่อ = models.CharField (max_length = 255)
ที่อยู่ = รุ่น TextField()
หมายเหตุ = รุ่น TextField()

ใน Hy:

(ลูกค้า defclass [models.Model]
[[ชื่อ (models.CharField :max-length 255})]
[ที่อยู่ (รุ่น.TextField)]
[หมายเหตุ (รุ่น TextField)]])

Hy <-> หลาม การทำงานร่วมกัน
โดยการนำเข้า Hy คุณสามารถใช้ Hy ได้โดยตรงจาก Python!

หากคุณบันทึกสิ่งต่อไปนี้ใน สวัสดี.hy:

(defn ทักทาย [ชื่อ] (พิมพ์ "สวัสดีจาก hy" ชื่อ))

จากนั้นคุณสามารถใช้มันได้โดยตรงจาก python โดยการนำเข้า hy ก่อนนำเข้าโมดูล ใน
หลาม:

นำเข้า hy
นำเข้าคำทักทาย

Greetings.greet("ฟู")

คุณยังสามารถประกาศฟังก์ชันใน python (หรือแม้แต่คลาส!) และใช้ใน Hy!

หากคุณบันทึกสิ่งต่อไปนี้ใน สวัสดี.py ในไพทอน:

def ทักทาย (ชื่อ):
พิมพ์ ("สวัสดี %s" % (ชื่อ))

คุณสามารถใช้ใน Hy:

(นำเข้าทักทาย)
(.greet ทักทาย "foo")

ในการใช้อาร์กิวเมนต์ของคีย์เวิร์ด คุณสามารถใช้in สวัสดี.py:

def ทักทาย (ชื่อ, title="เซอร์"):
พิมพ์ ("สวัสดี %s %s" % (ชื่อ, ชื่อ))

(นำเข้าทักทาย)
(.ทักทาย "ฟู")
(.ทักทาย "ฟู" "ดาร์ธ")
(สมัคร(.ทักทาย) ["Foo"] {"title" "พระเจ้า"})

ซึ่งจะส่งออก:

สวัสดีท่านฟู

สวัสดีดาร์ธฟู

สวัสดีท่านฟู

โปรทิปส์!
Hy ยังมีคุณลักษณะบางอย่างที่เรียกว่า "มาโครเธรด" ซึ่งเป็นคุณลักษณะที่ดีจริงๆของ
โคลจูร์. "มาโครเธรด" (เขียนเป็น ->) ใช้เพื่อหลีกเลี่ยงการซ้อนลึกของ
นิพจน์

แมโครเธรดแทรกแต่ละนิพจน์ลงในอาร์กิวเมนต์แรกของนิพจน์ถัดไป
แทน

มาดูความคลาสสิกกันดีกว่า:

(วนซ้ำ (พิมพ์ (eval (อ่าน))))

แทนที่จะเขียนอย่างนั้น เราสามารถเขียนได้ดังนี้:

(-> (อ่าน) (eval) (พิมพ์) (วนซ้ำ))

ตอนนี้ใช้ หลาม-shเราสามารถแสดงให้เห็นว่ามาโครเธรดได้อย่างไร (เนื่องจากการตั้งค่าของ python-sh)
สามารถใช้เป็นท่อ:

=> (นำเข้า [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 สไตล์ GUIDE

“รู้ไหม รัฐมนตรี ฉันไม่เห็นด้วยกับดัมเบิลดอร์ในหลายๆ ประการ…แต่คุณปฏิเสธไม่ได้ว่าเขาเป็น
มีสไตล์…” — Phineas Nigellus Black, Harry ช่างปั้น และ สั่งซื้อ of ต้นอินทผลัม

คู่มือสไตล์ Hy ตั้งใจที่จะเป็นชุดของกฎพื้นฐานสำหรับ Hyve (ใช่ ชุมชน Hy
ภาคภูมิใจในการผนวก Hy เข้ากับทุกสิ่ง) ในการเขียนโค้ด Hy ที่เป็นสำนวน Hy เกิดขึ้นมากมาย
จาก Clojure & Common Lisp ในขณะที่ยังคงความสามารถในการทำงานร่วมกันของ Python อยู่เสมอ

โหมโรง
พื้นที่ เต่า of Hy
อุมมณถามพระเศียรว่า “ท่านสอนพระสูตรอะไร?”
"พระสูตรนิพพาน"
“พระนิพพานพระสูตรมีคุณธรรมสี่ประการใช่หรือไม่”
"มันมี."
อมรถามพลางหยิบถ้วยว่า “สิ่งนี้มีคุณธรรมกี่ประการ”
“ไม่มีเลย” นักบวชกล่าว
“แต่คนโบราณบอกว่ามีใช่ไหม” อัมโมนกล่าว
“คุณคิดอย่างไรกับสิ่งที่พวกเขาพูด”
อุ้มตีถ้วยแล้วถามว่า "เข้าใจไหม"
“ไม่ใช่” พระภิกษุกล่าว
“ถ้าอย่างนั้น” อัมโมนพูด “เจ้าควรไปบรรยายในพระสูตรต่อไป”
— (โคอัน) มาโคร

ต่อไปนี้จะแสดงรายการสั้นๆ ของการตัดสินใจในการออกแบบที่นำไปสู่การทำ
Hy

· ดูเหมือนเสียงกระเพื่อม; DTRT ด้วย (เช่น ขีดกลางเปลี่ยนเป็นขีดล่าง ที่ปิดหูเปลี่ยนเป็น
ตัวพิมพ์ใหญ่ทั้งหมด)

· เรายังคงเป็น Python internals ส่วนใหญ่แปล 1:1 เป็น Python internals

· ใช้ Unicode ได้ทุกที่

· แก้ไขการตัดสินใจที่ไม่ดีใน Python 2 เมื่อเราทำได้ (ดู true_division).

· หากมีข้อสงสัย ให้เลื่อนไปที่ Python

· หากคุณยังไม่แน่ใจ ให้เลื่อนไปที่ Clojure

· หากคุณยิ่งไม่แน่ใจ ให้เลื่อนไปที่ Common Lisp

· โปรดทราบว่าเราไม่ใช่ Clojure เราไม่ใช่สามัญ Lisp พวกเรา Homoiconic Python ด้วย
บิตพิเศษที่เหมาะสม

แบบ & รอยหยัก
· หลีกเลี่ยงการเว้นวรรคต่อท้าย พวกเขาดูด!

· การเยื้องต้องมีช่องว่าง 2 ช่อง (ไม่มีแถบแข็ง) ยกเว้นเมื่อตรงกับการเยื้องของ
บรรทัดก่อนหน้า

;; ดี (และชอบ)
(defn fib [n])
(ถ้า (<= n 2)
n
(+ (ตอแหล (- น 1)) (ตอแหล (- น 2)))))

;; ยังไหว
(defn fib [n])
(ถ้า (<= n 2) n (+ (fib (- n 1)) (fib (- 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
(+ (ตอแหล (- n 1)) (ตอแหล (- n 2)))
)
) ; GAH เผามันด้วยไฟ

· จัดแนวตั้ง ให้ บล็อก

(ให้ [[foo (บาร์)]
[qux (บาซ)]]
(fo qux))

· ความคิดเห็นแบบอินไลน์จะต้องเป็นช่องว่างสองช่องจากส่วนท้ายของโค้ด พวกเขาจะต้องมี
ช่องว่างระหว่างอักขระความคิดเห็นและจุดเริ่มต้นของความคิดเห็น นอกจากนี้พยายามที่จะไม่
แสดงความคิดเห็นที่ชัดเจน

;; ดี
(setv ind (ธันวาคม x)); การจัดทำดัชนีเริ่มจาก0

;; เข้ากับสไตล์แต่บอกถึงความชัดเจน
(setv ind (ธันวาคม x)); ตั้งค่าดัชนีเป็น x-1

;; แย่
(setv ind (ธันวา x));พิมพ์คำเพื่อความสนุกสนาน

การเข้ารหัส สไตล์
· ตามธรรมเนียม พยายามอย่าใช้ def สำหรับสิ่งอื่นที่ไม่ใช่ตัวแปรส่วนกลาง ใช้ เซ็ตทีวี
ฟังก์ชันภายใน ลูป ฯลฯ

;; ดี (และชอบ)
(def *จำกัด* 400000)

(defn fibs [ab])
(ในขณะที่จริง
(ให้ผลก)
(setv (, ab) (, b (+ ab)))))

;; ไม่ดี (และไม่ชอบ)
(defn fibs [ab])
(ในขณะที่จริง
(ให้ผลก)
(def (, ab) (, b (+ ab)))))

· อย่าใช้วากยสัมพันธ์ s-expression โดยที่ไวยกรณ์แบบเวคเตอร์ตั้งใจไว้ ตัวอย่างเช่น ข้อเท็จจริง
ที่อดีตของทั้งสองตัวอย่างนี้ใช้งานได้เพียงเพราะคอมไพเลอร์ไม่ได้มากเกินไป
เข้มงวด. ในความเป็นจริง ไวยากรณ์ที่ถูกต้องในสถานที่เช่นนี้อยู่หลัง

;; ไม่ดี (และชั่วร้าย)
(defn foo (x) (พิมพ์ x))
(ฟู 1)

;; ดี (และชอบ)
(defn foo [x] (พิมพ์ x))
(ฟู 1)

· ใช้มาโครเธรดหรือมาโครหางของเธรดเมื่อพบการซ้อนกันอย่างล้ำลึก
s-นิพจน์ อย่างไรก็ตาม ควรใช้วิจารณญาณในการเลือกใช้ ใช้พวกเขาเมื่อความชัดเจนและ
การอ่านดีขึ้น; อย่าสร้างประโยคที่ซับซ้อนและเข้าใจยาก

;; ที่ต้องการ
(def *ชื่อ*
(ด้วย [f (เปิด "names.txt")]
(-> (.read f) (.strip) (.replace "\"" "") (.split ",") (sorted))))

;; ไม่ค่อยดี
(def *ชื่อ*
(ด้วย [f (เปิด "names.txt")]
(เรียงลำดับ (.split "," (.replace "\"" "" (.strip (.read f))))))

;; คงไม่ใช่ความคิดที่ดี
(defn สแควร์? [x]
(->> 2 (pow (int (sqrt x))) (= x)))

· ต้องการสัญกรณ์ดอทแบบ Clojure มากกว่าการเรียกเมธอดของอ็อบเจ็กต์โดยตรง
แม้ว่าทั้งสองจะยังคงได้รับการสนับสนุน

;; ดี
(ด้วย [fd (เปิด "/ etc / passwd")]
(พิมพ์ (.readlines fd)))

;; ไม่ค่อยดี
(ด้วย [fd (เปิด "/ etc / passwd")]
(พิมพ์ (fd.readlines)))

สรุป
“แฟชั่นจางหายไป สไตล์เป็นนิรันดร์” —อีฟส์ แซงต์ โลรองต์

คู่มือนี้เป็นเพียงชุดของแนวทางปฏิบัติของชุมชน และเห็นได้ชัดว่าแนวทางของชุมชนทำ
ไม่สมเหตุสมผลหากไม่มีชุมชนที่กระตือรือร้น ผลงานยินดีต้อนรับ เข้าร่วมกับเราที่ #hy ใน
freenode, บล็อกเกี่ยวกับมัน, ทวีตเกี่ยวกับมัน และที่สำคัญที่สุดคือ ขอให้สนุกกับ Hy

ขอบคุณ
· คู่มือนี้ได้รับแรงบันดาลใจมาจาก @พอลแท็ก บล็อกของ Hy การอยู่รอด แนะนำ

· Clojure สไตล์ แนะนำ

เอกสารฉบับ ดัชนี

เนื้อหา:

คำสั่ง Line อินเตอร์เฟซ
hy
คำสั่ง Line Options
-c
รันรหัส Hy ใน คำสั่ง.

$ hy -c "(พิมพ์ (+ 2 2))"
4

-i
รันรหัส Hy ใน คำสั่งจากนั้นอยู่ใน REPL

-m
รันรหัส Hy ใน โมดูลรวมทั้ง กำหนด ถ้ากำหนด

พื้นที่ -m แฟล็กยุติรายการตัวเลือกเพื่อให้อาร์กิวเมนต์ทั้งหมดหลังจาก โมดูล ชื่อ
ถูกส่งไปยังโมดูลใน sys.argv.

ใหม่ในเวอร์ชัน 0.10.2

--สอดแนม พิมพ์โค้ด Python ที่เทียบเท่าก่อนดำเนินการ ตัวอย่างเช่น:

=> (defn salutationsnm [ชื่อ] (พิมพ์ (+ "Hy " ชื่อ "!")))
def salutationsnm (ชื่อ):
ส่งคืนพิมพ์(((u'Hy ' + ชื่อ) + u'!'))
=> (คำทักทาย "ชื่อคุณ")
salutationsnm(u'YourName')
เฮ้ ชื่อของคุณ!
=>

ใหม่ในเวอร์ชัน 0.9.11

--show-ร่องรอย
พิมพ์การสืบค้นกลับแบบขยายสำหรับข้อยกเว้น Hy

ใหม่ในเวอร์ชัน 0.9.12

-v พิมพ์หมายเลขรุ่น Hy และออก

ไฮเปอร์
คำสั่ง Line Options
ไฟล์[, ไฟล์N]
รวบรวมรหัส Hy เป็น Python bytecode ตัวอย่างเช่น บันทึกรหัสต่อไปนี้เป็น
hyname.hy:

(defn hy-hy [ชื่อ]
(พิมพ์ (+ "Hy " ชื่อ "!")))

(hy-hy "Afroman")

จากนั้นเรียกใช้:

$hyc hyname.hy
$ หลาม hyname.pyc
ไฮ อาโฟรลัน!

ไฮทูพี
ใหม่ในเวอร์ชัน 0.10.1

คำสั่ง Line Options
-s

--พร้อมที่มา
แสดงโครงสร้างต้นทางที่แยกวิเคราะห์

-a

--กับ-ast
แสดง AST ที่สร้างขึ้น

-เช่น

--โดยไม่ต้องหลาม
อย่าแสดงโค้ด Python ที่สร้างจาก AST

Hy ( ภาษา)
คำเตือน:
นี้ไม่สมบูรณ์; โปรดพิจารณามีส่วนร่วมในความพยายามด้านเอกสาร

ทฤษฎี of Hy
Hy รักษาความเข้ากันได้ 100% ในทั้งสองทิศทางด้วย Python
ตัวเอง. รหัส Hy ทั้งหมดเป็นไปตามกฎง่ายๆ จำไว้เดี๋ยวมันก็เข้า
โทรศัพท์

กฎเหล่านี้ช่วยให้แน่ใจว่าโค้ด Hy เป็นสำนวนและใช้งานร่วมกันได้ทั้งสองภาษา

· สัญลักษณ์ใน earmufs จะถูกแปลเป็นเวอร์ชันตัวพิมพ์ใหญ่ของสตริงนั้น สำหรับ
ตัวอย่าง, foo จะกลายเป็น เอฟ.โอ.

· เอนทิตี UTF-8 จะถูกเข้ารหัสโดยใช้ Punycode และนำหน้าด้วย เฮีย_. ตัวอย่างเช่น ⚘
จะกลายเป็น hy_w7h, ♥ จะกลายเป็น hy_g6hและ ฉัน♥u จะกลายเป็น hy_iu_t0x.

· สัญลักษณ์ที่มีขีดกลางจะถูกแทนที่ด้วยขีดล่าง ตัวอย่างเช่น,
เทมเพลตการแสดงผล จะกลายเป็น เรนเดอร์_เทมเพลต. ซึ่งหมายความว่าสัญลักษณ์ที่มีขีดกลางจะ
เงาสิ่งที่เทียบเท่าขีดล่างและในทางกลับกัน

บิวท์อิน
Hy มีรูปแบบพิเศษจำนวนหนึ่งที่ใช้เพื่อช่วยสร้าง Python AST ที่ถูกต้อง
ต่อไปนี้เป็นรูปแบบ "พิเศษ" ซึ่งอาจมีลักษณะการทำงานที่ไม่คาดคิดเล็กน้อยใน
บางสถานการณ์

.
ใหม่ในเวอร์ชัน 0.10.0

. ใช้เพื่อดำเนินการเข้าถึงแอตทริบิวต์บนวัตถุ ใช้ DSL ขนาดเล็กเพื่อให้รวดเร็ว
การเข้าถึงแอตทริบิวต์และรายการในโครงสร้างข้อมูลที่ซ้อนกัน

ยกตัวอย่างเช่น

(.foo bar baz [(+ 1 2)] ฟอง)

รวบรวมลงไป:

foo.bar.baz[1 + 2].frob

. รวบรวมอาร์กิวเมนต์แรก (ในตัวอย่าง foo) เป็นวัตถุที่จะทำ
แอตทริบิวต์ dereference ใช้สัญลักษณ์เปล่าเป็นแอตทริบิวต์ในการเข้าถึง (ในตัวอย่าง บาร์,
ฐาน, ฟอง) และรวบรวมเนื้อหาของรายการ (ในตัวอย่าง [(+ 1 2)]]) สำหรับการจัดทำดัชนี
อาร์กิวเมนต์อื่นทำให้เกิดข้อผิดพลาดในการรวบรวม

การเข้าถึงแอตทริบิวต์ที่ไม่รู้จักพ่นและ ข้อผิดพลาดแอตทริบิวต์. การเข้าถึงคีย์ที่ไม่รู้จักพ่นและ
ดัชนีข้อผิดพลาด (ในรายการและทูเพิล) หรือ a ข้อผิดพลาดที่สำคัญ (ในพจนานุกรม).

->
-> (หรือ เกลียว แมโคร) ใช้เพื่อหลีกเลี่ยงการซ้อนนิพจน์ มาโครเกลียว
แทรกแต่ละนิพจน์ลงในตำแหน่งอาร์กิวเมนต์แรกของนิพจน์ถัดไป ต่อไปนี้
รหัสแสดงให้เห็นสิ่งนี้:

=> (defn เอาต์พุต [ab] (พิมพ์ ab))
=> (-> (+ 4 6) (เอาต์พุต 5))
10 5

- >>
- >> (หรือ เกลียว หาง แมโคร) คล้ายกับ เกลียว แมโครแต่แทนที่จะเป็น
การแทรกแต่ละนิพจน์ลงในอาร์กิวเมนต์แรกของนิพจน์ถัดไป จะต่อท้ายเป็น
อาร์กิวเมนต์สุดท้าย รหัสต่อไปนี้แสดงให้เห็นสิ่งนี้:

=> (defn เอาต์พุต [ab] (พิมพ์ ab))
=> (->> (+ 4 6) (เอาต์พุต 5))
5 10

ใช้
ใช้ ใช้เพื่อใช้รายการอาร์กิวเมนต์ที่เป็นทางเลือกและพจนานุกรมทางเลือกของkwargs
เป็นฟังก์ชัน

การใช้งาน: (นำมาใช้ Fn-ชื่อ [อาร์กิวเมนต์] [ควาร์ก])

ตัวอย่าง:

(ป้องกันทัน []
"นี่ไง")

(ใช้ตังค์)
;=> "นี่ไง"

(defn ยอดซื้อทั้งหมด [ราคา & ตัวเลือก [ค่าธรรมเนียม 1.05] [vat 1.1]]
(* ราคา จำนวน ค่าธรรมเนียม vat))

(ใช้ยอดซื้อ [10 15])
;=> 173.25

(ใช้ยอดซื้อ [10 15] {"vat" 1.05})
;=> 165.375

(ใช้ยอดซื้อ [] {"price" 10 "amount" 15 "vat" 1.05})
;=> 165.375

และ
และ ใช้ในนิพจน์เชิงตรรกะ ต้องใช้อย่างน้อยสองพารามิเตอร์ ถ้าพารามิเตอร์ทั้งหมด
ประเมินเพื่อ จริงพารามิเตอร์สุดท้ายจะถูกส่งคืน ในกรณีอื่น ๆ ค่าเท็จตัวแรก
จะถูกส่งกลับ ตัวอย่างการใช้งาน:

=> (และจริงเท็จ)
เท็จ

=> (และทรู ทรู)
จริง

=> (และทรู 1)
1

=> (และ จริง [] เท็จ จริง)
[]

หมายเหตุ:
และ ลัดวงจรและหยุดการประเมินพารามิเตอร์ทันทีที่ค่าเท็จตัวแรกคือ
ได้พบเจอ

=> (และเท็จ (พิมพ์ "สวัสดี"))
เท็จ

ยืนยัน
ยืนยัน ใช้สำหรับตรวจสอบเงื่อนไขขณะโปรแกรมกำลังทำงาน ถ้าเงื่อนไขไม่
ได้เจอ ยืนยันข้อผิดพลาด ถูกยกขึ้น ยืนยัน อาจใช้หนึ่งหรือสองพารามิเตอร์ ครั้งแรก
พารามิเตอร์เป็นเงื่อนไขที่จะตรวจสอบและควรประเมินเป็น จริง or เท็จ.
พารามิเตอร์ที่สอง เป็นทางเลือก เป็นเลเบลสำหรับการยืนยัน และเป็นสตริงที่จะ
เลี้ยงด้วย ยืนยันข้อผิดพลาด. ตัวอย่างเช่น:

(ยืนยัน (= ตัวแปรค่าคาดหวัง))

(ยืนยันเท็จ)
; ยืนยันข้อผิดพลาด

(ยืนยัน (= 1 2) "หนึ่งควรเท่ากับสอง")
; AssertionError: หนึ่งควรเท่ากับสอง

รศ
รศ ใช้เพื่อเชื่อมโยงคีย์กับค่าในพจนานุกรมหรือเพื่อกำหนดดัชนีของรายการ
เป็นค่า ต้องใช้พารามิเตอร์อย่างน้อยสามตัว: the ข้อมูล โครงสร้าง ที่จะแก้ไข a สำคัญ
or ดัชนีและใน ความคุ้มค่า. หากใช้พารามิเตอร์มากกว่าสามตัว พารามิเตอร์จะเชื่อมโยงกันเป็นคู่

ตัวอย่างการใช้งาน:

=>(ให้ [[คอลเลกชัน {}]]
... (รศ. สะสม "หมา" "เห่า")
... (ชุดพิมพ์))
{u'Dog': u'Bark'}

=>(ให้ [[คอลเลกชัน {}]]
... (รศ. สะสม "หมา" "เห่า" "แมว" "เหมียว")
... (ชุดพิมพ์))
{u'Cat': u'Meow', u'Dog': u'Bark'}

=>(ให้ [[คอลเลกชัน [1 2 3 4]]]
... (รศ. 2 ไม่มี)
... (ชุดพิมพ์))
[1, 2, ไม่มี, 4]

หมายเหตุ:
รศ แก้ไขโครงสร้างข้อมูลในตำแหน่งและส่งคืน ไม่มี.

ทำลาย
ทำลาย ใช้เพื่อแยกออกจากลูป มันยุติการวนซ้ำทันที ต่อไปนี้
ตัวอย่างมีอนันต์ ในขณะที่ วนซ้ำที่สิ้นสุดทันทีที่ผู้ใช้เข้าสู่ k.

(ในขณะที่ True (ถ้า (= "k" (raw-input "? "))
(หยุดพัก)
(พิมพ์ "ลองอีกครั้ง")))

เงื่อนไข
เงื่อนไข สามารถใช้สร้างซ้อนกันได้ if งบ. ตัวอย่างต่อไปนี้แสดงให้เห็น
ความสัมพันธ์ระหว่างมาโครกับการขยาย:

(เงื่อนไข [เงื่อนไข-1 ผล-1]
[เงื่อนไข-2 ผลลัพธ์-2])

(ถ้าเงื่อนไข-1 ผล-1
(ถ้าเงื่อนไข-2 ผลลัพธ์-2))

ดังที่แสดงด้านล่าง เฉพาะบล็อกผลลัพธ์ที่ตรงกันชุดแรกเท่านั้นที่จะถูกดำเนินการ

=> (defn ตรวจสอบค่า [value]
... (cond [(<value 5) (พิมพ์ "value น้อยกว่า 5")]
... [(= ค่า 5) (พิมพ์ "ค่าเท่ากับ 5")]
... [(> ค่า 5) (พิมพ์ "ค่ามากกว่า 5")]
... [True (พิมพ์ว่า "ค่าคือสิ่งที่ไม่ควรเป็น")]))

=> (เช็คค่า 6)
ค่ามากกว่า 5

ต่อ
ต่อ ส่งคืนการดำเนินการไปยังจุดเริ่มต้นของการวนซ้ำ ในตัวอย่างต่อไปนี้
(ผลข้างเคียง1) ถูกเรียกสำหรับการวนซ้ำแต่ละครั้ง (ผลข้างเคียง2)อย่างไรก็ตาม เรียกเฉพาะเมื่อ
ทุกค่าอื่นๆ ในรายการ

;; สมมติว่า (ผลข้างเคียง1) และ (ผลข้างเคียง2) เป็นฟังก์ชันและ
;; คอลเลกชันคือรายการของค่าตัวเลข

(สำหรับ [คอลเลกชัน x]
(เนื่องจาก
(ผลข้างเคียง1 x)
(ถ้า (% x 2)
(ดำเนินต่อ))
(ผลข้างเคียง2 x)))

dict-คอมพ์
dict-คอมพ์ ใช้ในการสร้างพจนานุกรม ใช้พารามิเตอร์สามหรือสี่ตัว ครั้งแรก
พารามิเตอร์สองตัวใช้สำหรับควบคุมค่าส่งคืน (คู่คีย์-ค่า) ในขณะที่ is . ตัวที่สาม
ใช้เพื่อเลือกรายการจากลำดับ พารามิเตอร์ที่สี่และทางเลือกสามารถใช้เพื่อ
กรองบางรายการในลำดับตามนิพจน์เงื่อนไข

=> (dict-comp x (* x 2) [x (ช่วง 10)] (คี่? x))
{1:2, 3:6, 9:18, 5:10, 7:14}

do / การคาดการณ์
do และ การคาดการณ์ ใช้เพื่อประเมินข้อโต้แย้งแต่ละรายการและส่งคืนข้อโต้แย้งสุดท้าย กลับ
ค่าจากทุกค่าที่ไม่ใช่อาร์กิวเมนต์สุดท้ายจะถูกละทิ้ง สามารถใช้ได้ใน แลมบ์ดา or
รายการเปรียบเทียบ เพื่อดำเนินการตรรกะที่ซับซ้อนมากขึ้นตามที่แสดงในตัวอย่างต่อไปนี้

ตัวอย่างการใช้งาน:

=> (ถ้าจริง
... (ทำ (พิมพ์ "ผลข้างเคียง!")
... (พิมพ์ "ใช่จริงๆ!")))
ผลข้างเคียง ร็อค!
ใช่จริงๆ!

;; สมมติว่า (ผลข้างเคียง) เป็นฟังก์ชันที่เราอยากเรียกหากัน
;; และทุกค่าในรายการแต่กลับมีค่าที่เราไม่สนใจ
=> (list-comp (ทำ (ผลข้างเคียง x)
... (ถ้า (< x 5) (* 2 x)
... (* 4 x)))
... (x (ช่วง 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do สามารถยอมรับอาร์กิวเมนต์จำนวนเท่าใดก็ได้ตั้งแต่ 1 ถึง n

def / เซ็ตทีวี
def และ เซ็ตทีวี ใช้เพื่อผูกค่า วัตถุ หรือฟังก์ชันกับสัญลักษณ์ ตัวอย่างเช่น:

=> (def ชื่อ ["อลิซ" "บ๊อบ" "ชาร์ลี"])
=> (พิมพ์ชื่อ)
[u'Alice', u'Bob', u'Charlie']

=> (ตัวนับ setv (fn [collection item] (.count collection item)))
=> (เคาน์เตอร์ [1 2 3 4 5 2 3] 2)
2

defclass
ประกาศคลาสใหม่ด้วย defclass. สามารถใช้พารามิเตอร์ทางเลือกได้สองแบบ: vector
กำหนด super class ที่เป็นไปได้และเวกเตอร์อื่นที่มีคุณสมบัติของ new
คลาสเป็นเวกเตอร์สองไอเท็ม

(defclass ชื่อคลาส [super-class-1 super-class-2]
[[ค่าแอตทริบิวต์]])

ทั้งค่าและฟังก์ชันสามารถผูกกับคลาสใหม่ได้ดังตัวอย่างด้านล่าง:

=> (defclass Cat []
... [[อายุ ไม่มี]
... [สี "ขาว"]
... [พูด (fn [ตัวเอง] (พิมพ์ "เหมียว"))]])

=> (def spot (แมว))
=> (setv spot.color "Black")
'สีดำ'
=> (จุด .Speak)
เหมียว

ป้องกัน / ทำลาย
ป้องกัน และ ทำลาย มาโครใช้เพื่อกำหนดฟังก์ชัน ใช้พารามิเตอร์สามตัว: the ชื่อ
ของฟังก์ชันที่จะกำหนด เวกเตอร์ของ พารามิเตอร์และ ร่างกาย ของฟังก์ชัน:

(ชื่อเรียก [params] ร่างกาย)

พารามิเตอร์อาจมีคีย์เวิร์ดต่อไปนี้อยู่ข้างหน้า:

&ไม่จำเป็น
พารามิเตอร์เป็นตัวเลือก พารามิเตอร์สามารถกำหนดเป็นรายการสองรายการ โดยที่
องค์ประกอบแรกคือชื่อพารามิเตอร์และองค์ประกอบที่สองคือค่าเริ่มต้น พารามิเตอร์
สามารถกำหนดเป็นรายการเดียวได้ ซึ่งในกรณีนี้ ค่าเริ่มต้นคือ ไม่มี.

=> (defn มูลค่ารวม [มูลค่า & ทางเลือก [ภาษีมูลค่าเพิ่ม 10]]
... (+ (/ (* มูลค่าเพิ่ม-ภาษี) 100) มูลค่า))

=> (มูลค่ารวม 100)
110.0

=> (มูลค่ารวม 100 1)
101.0

&กุญแจ

&kwargs
พารามิเตอร์จะมีอาร์กิวเมนต์ของคีย์เวิร์ดตั้งแต่ 0 รายการขึ้นไป

ตัวอย่างโค้ดต่อไปนี้กำหนดฟังก์ชันที่จะพิมพ์คีย์เวิร์ดทั้งหมด
อาร์กิวเมนต์และค่านิยมของพวกเขา

=> (พารามิเตอร์การพิมพ์ defn [&kwargs kwargs]
... (สำหรับ [(, kv) (.items kwargs)] (พิมพ์ kv)))

=> (ใช้พารามิเตอร์การพิมพ์ [] {"parameter-1" 1 "parameter-2" 2})
พารามิเตอร์-2 2
พารามิเตอร์-1 1

&พักผ่อน พารามิเตอร์จะมีอาร์กิวเมนต์ตำแหน่ง 0 หรือมากกว่า ไม่มีตำแหน่งอื่น
อาจมีการระบุอาร์กิวเมนต์หลังจากนี้

ตัวอย่างโค้ดต่อไปนี้กำหนดฟังก์ชันที่สามารถให้ 0 ถึง n ตัวเลข
พารามิเตอร์ จากนั้นจะรวมทุกเลขคี่และลบทุกเลขคู่

=> (defn zig-zag-sum [&หมายเลขที่เหลือ]
(ให้ [[เลขคี่ (list-comp x [x numbers] (คี่? x))]
[เลขคู่ (list-comp x [x numbers] (คู่? x))]]
(- (ผลรวมเลขคี่) (ผลรวมเลขคู่))))

=> (ซิกแซกซัม)
0
=> (ซิกแซกซัม 3 9 4)
8
=> (ซิกแซกซัม 1 2 3 4 5 6)
-3

defn-นามแฝง / defun-นามแฝง
ใหม่ในเวอร์ชัน 0.10.0

พื้นที่ defn-นามแฝง และ defun-นามแฝง มาโครก็เหมือน ป้องกันด้วยความแตกต่างที่ว่า
แทนที่จะกำหนดฟังก์ชันด้วยชื่อเดียว ฟังก์ชันเหล่านี้ยังสามารถกำหนดนามแฝงได้อีกด้วย อื่น
กว่าการนำรายการสัญลักษณ์สำหรับชื่อฟังก์ชันมาเป็นพารามิเตอร์แรก defn-นามแฝง และ
defun-นามแฝง ก็ไม่ต่างจาก ป้องกัน และ ทำลาย.

=> (defn-alias [นามแฝงหลัก] []
... (พิมพ์ "สวัสดี!"))
=> (ชื่อหลัก)
"สวัสดี!"
=> (นามแฝง)
"สวัสดี!"

กำหนด
ใหม่ในเวอร์ชัน 0.10.1

พื้นที่ กำหนด มาโครกำหนดฟังก์ชันหลักที่เรียกทันทีด้วย sys.argv as
อาร์กิวเมนต์ก็ต่อเมื่อไฟล์นี้ถูกเรียกใช้งานเป็นสคริปต์ กล่าวอีกนัยหนึ่งสิ่งนี้:

(defmain [&rest args]
(ทำอะไรบางอย่างกับ args))

เทียบเท่ากับ:

def หลัก (*args):
do_something_with(หาเรื่อง)
ส่งคืน 0

ถ้า __name__ == "__main__":
sys นำเข้า
retval = หลัก (* sys.arg)

ถ้า isinstance(retval, int):
sys.exit(การย้อนกลับ)

โปรดทราบว่าดังที่คุณเห็นด้านบน หากคุณคืนค่าจำนวนเต็มจากฟังก์ชันนี้ ค่านี้จะเป็น
ใช้เป็นสถานะออกสำหรับสคริปต์ของคุณ (ค่าเริ่มต้นของ Python เป็นสถานะออก 0 มิฉะนั้น
ซึ่งหมายความว่าทุกอย่างโอเค!)

(ตั้งแต่ (sys.exit 0) ไม่ทำงานอย่างชัดเจนในกรณีของการส่งคืนที่ไม่ใช่จำนวนเต็มจาก
กำหนด,เป็นความคิดที่ดีที่จะใส่ (กำหนด) เป็นโค้ดสุดท้ายในไฟล์ของคุณ)

เดฟมาโคร
เดฟมาโคร ใช้เพื่อกำหนดมาโคร รูปแบบทั่วไปคือ (defmacro ชื่อ [พารามิเตอร์]
ประสบการณ์).

ตัวอย่างต่อไปนี้กำหนดมาโครที่สามารถใช้เพื่อสลับลำดับขององค์ประกอบในโค้ด
อนุญาตให้ผู้ใช้เขียนรหัสในรูปแบบ infix โดยที่ตัวดำเนินการอยู่ระหว่าง
ตัวถูกดำเนินการ

=> (รหัส defmacro [รหัส]
... (ควอสิโควต (
... (unquote (รับรหัส 1))
... (unquote (รับรหัส 0))
... (unquote (รับรหัส 2)))))

=> (คำนำหน้า (1 + 1))
2

defmacro-นามแฝง
defmacro-นามแฝง ใช้เพื่อกำหนดมาโครที่มีหลายชื่อ (นามแฝง) รูปแบบทั่วไป
is (defmacro-นามแฝง [ชื่อ] [พารามิเตอร์] ประสบการณ์). มันสร้างมาโครหลายตัวที่เหมือนกัน
รายการพารามิเตอร์และเนื้อหาภายใต้รายชื่อที่ระบุ

ตัวอย่างต่อไปนี้กำหนดมาโครสองตัว ซึ่งทั้งคู่อนุญาตให้ผู้ใช้เขียนโค้ดใน
สัญกรณ์ infix

=> (defmacro-alias [infix infi] [รหัส]
... (ควอสิโควต (
... (unquote (รับรหัส 1))
... (unquote (รับรหัส 0))
... (unquote (รับรหัส 2)))))

=> (คำนำหน้า (1 + 1))
2
=> (อินฟี (1 + 1))
2

เดฟมาโคร/g!
ใหม่ในเวอร์ชัน 0.9.12

เดฟมาโคร/g! เป็นรุ่นพิเศษของ เดฟมาโคร ที่ใช้สร้างโดยอัตโนมัติ เจนซิม
สำหรับสัญลักษณ์ใดๆ ที่ขึ้นต้นด้วย g!.

ตัวอย่างเช่น ก!ก จะกลายเป็น (เจนซิม "ก").

SEE เพิ่มเติม:
ส่วนใช้-gensym

ผู้ทำลาย
ใหม่ในเวอร์ชัน 0.9.12

ผู้ทำลาย กำหนดมาโครตัวอ่าน ทำให้คุณสามารถจัดโครงสร้างใหม่หรือแก้ไขไวยากรณ์ได้

=> (defreader ^ [expr] (พิมพ์ expr))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"สวัสดี"
"สวัสดี"

SEE เพิ่มเติม:
มาโครตัวอ่านส่วน

เดล
ใหม่ในเวอร์ชัน 0.9.12

เดล ลบวัตถุออกจากเนมสเปซปัจจุบัน

=> (setv foo 42)
=> (เดลฟู)
=> ฟู
Traceback (โทรล่าสุดล่าสุด):
ไฟล์ " ", บรรทัดที่ 1, ใน
NameError: ไม่ได้กำหนดชื่อ 'foo'

เดล ยังสามารถลบออบเจ็กต์ออกจากการแมป รายการ และอื่นๆ

=> (ทดสอบ setv (รายการ (ช่วง 10)))
=> ทดสอบ
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (เดล (ทดสอบสไลซ์ 2 4)) ;; ลบรายการจาก 2 ถึง 4 ไม่รวม
=> ทดสอบ
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "bar"})
=> ดิก
{"foo": "บาร์"}
=> (เดล (รับ dic "foo"))
=> ดิก
{}

ทำ
ใหม่ในเวอร์ชัน 0.10.1

ทำ ใช้เพื่อลดความซับซ้อนของลำดับการเรียกใช้เมธอดไปยังอ็อบเจ็กต์

=> (doto [] (.append 1) (.append 2) .reverse)
[2 1]

=> (คอลเลกชัน setv [])
=> (.append ชุดที่ 1)
=> (.append ชุดที่ 2)
=> (.reverse คอลเลกชัน)
=> คอลเลกชัน
[2 1]

ประเมิน
ประเมิน ประเมินนิพจน์ที่ยกมาและส่งกลับค่า

=> (eval '(พิมพ์ "สวัสดีชาวโลก"))
"สวัสดีชาวโลก"

eval-และคอมไพล์
eval เมื่อคอมไพล์
เป็นครั้งแรก / รถ
เป็นครั้งแรก และ รถ เป็นมาโครสำหรับเข้าถึงองค์ประกอบแรกของคอลเลกชัน:

=> (ช่วงแรก (ช่วง 10))
0

for
for ใช้เพื่อเรียกใช้ฟังก์ชันสำหรับแต่ละองค์ประกอบในรายการหรือเวกเตอร์ ผลลัพธ์ของแต่ละคน
การโทรถูกยกเลิกและ for การแสดงออกกลับ ไม่มี แทนที่. ตัวอย่างโค้ด iterates
เกิน ชุด และสำหรับแต่ละคน ธาตุ in ชุด เรียกไฟล์ ผลข้างเคียง ฟังก์ชั่นด้วย
ธาตุ เป็นอาร์กิวเมนต์:

;; สมมติว่า (ผลข้างเคียง) เป็นฟังก์ชันที่ใช้พารามิเตอร์ตัวเดียว
(สำหรับ [การรวบรวมองค์ประกอบ] (องค์ประกอบผลข้างเคียง))

;; สำหรับสามารถเลือกบล็อกอื่นได้
(สำหรับ [การรวบรวมองค์ประกอบ] (องค์ประกอบผลข้างเคียง)
(อื่น ๆ (ผลข้างเคียง -2)))

ตัวเลือก อื่น บล็อกจะดำเนินการก็ต่อเมื่อ for ลูปสิ้นสุดตามปกติ ถ้า
การดำเนินการจะหยุดด้วย ทำลายที่ อื่น บล็อกไม่ดำเนินการ

=> (สำหรับ [องค์ประกอบ [1 2 3]] (ถ้า (< องค์ประกอบ 3)
... (องค์ประกอบการพิมพ์)
... (หยุดพัก))
... (อื่น (พิมพ์ "วนรอบเสร็จแล้ว")))
1
2

=> (สำหรับ [องค์ประกอบ [1 2 3]] (ถ้า (< องค์ประกอบ 4)
... (องค์ประกอบการพิมพ์)
... (หยุดพัก))
... (อื่น (พิมพ์ "วนรอบเสร็จแล้ว")))
1
2
3
วนเสร็จ

เจนเอ็กซ์พีอาร์
เจนเอ็กซ์พีอาร์ ใช้เพื่อสร้างนิพจน์ตัวสร้าง ใช้พารามิเตอร์สองหรือสามตัว ดิ
พารามิเตอร์แรกคือนิพจน์ที่ควบคุมค่าที่ส่งกลับในขณะที่ใช้ตัวที่สอง
เพื่อเลือกรายการจากรายการ พารามิเตอร์ที่สามและตัวเลือกเสริมสามารถใช้เพื่อกรอง
บางรายการในรายการตามนิพจน์เงื่อนไข เจนเอ็กซ์พีอาร์ มีความคล้ายคลึงกับ
รายการเปรียบเทียบยกเว้นว่าจะส่งกลับ iterable ที่ประเมินค่าทีละตัวแทนที่จะเป็น
ประเมินผลทันที

=> (การรวบรวม def (ช่วง 10))
=> (def กรอง (genexpr x [x คอลเลกชัน] (แม้กระทั่ง? x)))
=> (รายการที่กรอง)
[0, 2, 4, 6, 8]

เจนซิม
ใหม่ในเวอร์ชัน 0.9.12

เจนซิม ใช้เพื่อสร้างสัญลักษณ์เฉพาะที่ช่วยให้สามารถเขียนมาโครโดยไม่ต้อง
การชนกันของชื่อตัวแปรโดยไม่ได้ตั้งใจ

=> (เกนซิม)
คุณ:G_1235'

=> (gensym "x")
คุณ:x_1236'

SEE เพิ่มเติม:
ส่วนใช้-gensym

ได้รับ
ได้รับ ใช้เพื่อเข้าถึงองค์ประกอบเดียวในรายการและพจนานุกรม ได้รับ รับสองพารามิเตอร์:
ข้อมูล โครงสร้าง และ ดัชนี or สำคัญ ของรายการ จากนั้นจะส่งคืนที่สอดคล้องกัน
ค่าจากพจนานุกรมหรือรายการ ตัวอย่างการใช้งาน:

=> (ให้ [[สัตว์ {"หมา" "เห่า" "แมว" "เหมียว"}]
... [ตัวเลข ["ศูนย์" "หนึ่ง" "สอง" "สาม"]]]
... (พิมพ์ (รับสัตว์ "สุนัข"))
... (พิมพ์ (ได้ตัวเลข 2)))
เปลือกไม้
สอง

หมายเหตุ:
ได้รับ ทำให้เกิด KeyError หากมีการสอบถามพจนานุกรมสำหรับคีย์ที่ไม่มีอยู่

หมายเหตุ:
ได้รับ เพิ่ม IndexError ถ้ารายการหรือทูเพิลถูกสอบถามสำหรับดัชนีที่ออกจาก
ขอบเขต

ทั่วโลก
ทั่วโลก สามารถใช้เพื่อทำเครื่องหมายสัญลักษณ์เป็นสากล สิ่งนี้ทำให้โปรแกรมเมอร์สามารถกำหนดa
ค่าเป็นสัญลักษณ์สากล การอ่านสัญลักษณ์สากลไม่จำเป็นต้องมี ทั่วโลก คำสำคัญ --
เฉพาะการมอบหมายเท่านั้น

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสัญลักษณ์สากล a ถูกกำหนดเป็นค่าในฟังก์ชันและ
ภายหลังถูกพิมพ์ในฟังก์ชันอื่น ปราศจาก ทั่วโลก คีย์เวิร์ด ฟังก์ชันที่สอง
จะได้โยน ชื่อผิดพลาด.

(defn set-a [ค่า]
(ทั่วโลกก)
(ตั้งค่า))

(defn พิมพ์-a []
(พิมพ์ก))

(ชุด-a 5)
(พิมพ์-a)

if / ถ้าไม่
ใหม่ในเวอร์ชัน 0.10.0: if-not

if ใช้สำหรับเลือกรหัสแบบมีเงื่อนไขเพื่อดำเนินการ ต้องมีเงื่อนไข
บล็อกและบล็อกที่จะดำเนินการหากบล็อกเงื่อนไขประเมินเป็น จริง. หรือ
มันอาจมีบล็อกสุดท้ายที่ดำเนินการในกรณีที่การประเมินเงื่อนไขคือ
เท็จ.

ถ้าไม่ คล้ายกัน แต่บล็อกที่สองจะถูกดำเนินการเมื่อเงื่อนไขล้มเหลวในขณะที่
บล็อกที่สามและสุดท้ายจะดำเนินการเมื่อการทดสอบสำเร็จ - ลำดับที่ตรงกันข้ามของ if.

ตัวอย่างการใช้งาน:

(ถ้า(เงินเหลือ?บัญชี)
(พิมพ์ "ไปช้อปปิ้งกัน")
(พิมพ์ "ไปทำงานกันเถอะ"))

(ถ้าไม่ใช่ (เงินเหลือ? บัญชี)
(พิมพ์ "ไปทำงานกันเถอะ")
(พิมพ์ "ไปช้อปปิ้งกัน"))

ความจริงของ Python เป็นที่เคารพนับถือ ไม่มี, เท็จ, ศูนย์ของตัวเลขใดๆ, ลำดับว่าง,
และพจนานุกรมเปล่าถือว่า เท็จ; อย่างอื่นถือว่าหมด จริง.

เสียงกระเพื่อมถ้า / ไฟเบอร์ และ เสียงกระเพื่อมถ้าไม่ / ลิฟ-ไม่
ใหม่ในเวอร์ชัน 0.10.0

ใหม่ในเวอร์ชัน 0.10.2: lisp-if-not / lif-not

สำหรับผู้ที่ชอบ Lispy มากกว่า if ข้อ เรามี เสียงกระเพื่อมถ้า,หรือ ไฟเบอร์. นี้ เพียง พิจารณา
ไม่มี / ศูนย์ ที่จะเป็นเท็จ! ค่า Python "false-ish" อื่นๆ ทั้งหมดถือเป็นค่าจริง
ในทางกลับกัน เรามี เสียงกระเพื่อมถ้าไม่ และ ลิฟ-ไม่ ควบคู่ไปกับ if และ ถ้าไม่ ซึ่งกลับกัน
การเปรียบเทียบ

=> (lisp-if จริง "จริง" "เท็จ")
"จริง"
=> (lisp-if เท็จ "จริง" "เท็จ")
"จริง"
=> (lisp-if 0 "จริง" "เท็จ")
"จริง"
=> (lisp-if nil "จริง" "เท็จ")
"เท็จ"
=> (lisp-ถ้าไม่มี "จริง" "เท็จ")
"เท็จ"
=> (lisp-if-not nil "true" "false")
"จริง"
=> (lisp-if-not none "จริง" "เท็จ")
"จริง"
=> (lisp-if-not False "จริง" "เท็จ")
"เท็จ"

; เทียบเท่าแต่สั้นกว่า
=> (ถ้าจริง "จริง" "เท็จ")
"จริง"
=> (ถ้าไม่มี "จริง" "เท็จ")
"เท็จ"
=> (lif-not none "จริง" "เท็จ")
"จริง"

นำเข้า
นำเข้า ใช้เพื่อนำเข้าโมดูลเช่นใน Python มีหลายวิธีที่จะ นำเข้า สามารถ
นำไปใช้

;; นำเข้าแต่ละโมดูลเหล่านี้
;;
;; หลาม:
;; นำเข้าsys
;; นำเข้า os.path
(นำเข้า sys os.path)

;; นำเข้าจากโมดูล
;;
;; Python: มีการนำเข้าจาก os.path, isdir, isfile
(นำเข้า [os.path [มี isdir isfile]])

;; นำเข้าด้วยนามแฝง
;;
;; Python: นำเข้า sys เป็น systest
(นำเข้า [sys :as systest])

;; คุณสามารถแสดงรายการการนำเข้าประเภทต่างๆ ได้มากเท่าที่คุณต้องการ
(นำเข้า [tests.resources [kwtest function-with-a-dash]]
[os.path [มี isdir isfile]]
[sys:as systest])

;; นำเข้าฟังก์ชันโมดูลทั้งหมดลงในเนมสเปซปัจจุบัน
(นำเข้า [sys [*]])

แลมบ์ดา / fn
แลมบ์ดา และ fn สามารถใช้เพื่อกำหนดฟังก์ชันที่ไม่ระบุชื่อ พารามิเตอร์จะคล้ายกับ
ป้องกัน: พารามิเตอร์แรกคือเวกเตอร์ของพารามิเตอร์ ส่วนที่เหลือคือเนื้อหาของ
ฟังก์ชัน แลมบ์ดา ส่งคืนฟังก์ชันใหม่ ในตัวอย่างต่อไปนี้ ฟังก์ชันนิรนาม
ถูกกำหนดและส่งผ่านไปยังฟังก์ชันอื่นเพื่อกรองเอาท์พุต

=> (def คน [{:name "Alice" :age 20}
... {:ชื่อ "บ๊อบ" :อายุ 25}
... {:name "ชาลี" :อายุ 50}
... {:ชื่อ "เดฟ" :อายุ 5 }])

=> (defn display-people [ตัวกรองผู้คน]
... (สำหรับ [คนคน] (ถ้า (คนกรอง) (พิมพ์ (: ชื่อคน))))

=> (คนแสดงคน (fn [คน] (< (: อายุคน) 25)))
อลิซ
เดฟ

เช่นเดียวกับในนิยามฟังก์ชันปกติ หากองค์ประกอบแรกของเนื้อหาเป็นสตริง มัน
ทำหน้าที่เป็น docstring สิ่งนี้มีประโยชน์สำหรับการจัดเตรียมเอกสารเกี่ยวกับเมธอดของคลาส

=> (setv คูณ - สาม
... (ฉ [x]
... "คูณอินพุตด้วยสามและส่งคืนผลลัพธ์"
... (* x 3)))

สิ่งนี้สามารถยืนยันได้ผ่าน built-in . ของ Python ช่วย ฟังก์ชั่น:

=> (ช่วย คูณสาม)
ความช่วยเหลือเกี่ยวกับฟังก์ชัน times_three:

ครั้ง_สาม(x)
คูณอินพุตด้วยสามและส่งคืนผลลัพธ์
(จบ)

ล่าสุด
ใหม่ในเวอร์ชัน 0.10.2

ล่าสุด สามารถใช้สำหรับการเข้าถึงองค์ประกอบสุดท้ายของคอลเลกชัน:

=> (สุดท้าย [2 4 6])
6

ให้
ให้ ใช้เพื่อสร้างตัวแปรที่มีขอบเขตคำศัพท์ พวกเขาถูกสร้างขึ้นที่จุดเริ่มต้นของ
ให้ แบบฟอร์มและสิ้นสุดลงหลังจากแบบฟอร์ม ตัวอย่างต่อไปนี้แสดงสิ่งนี้
พฤติกรรม:

=> (ให้ [[x 5]] (พิมพ์ x)
... (ให้ [[x 6]] (พิมพ์ x))
... (พิมพ์ x))
5
6
5

พื้นที่ ให้ มาโครใช้พารามิเตอร์สองตัว: การกำหนดเวกเตอร์ ตัวแปร และ ร่างกาย ที่ได้รับ
ดำเนินการ ตัวแปร เป็นเวกเตอร์โดยที่แต่ละองค์ประกอบเป็นตัวแปรเดียวหรือเวกเตอร์
การกำหนดคู่ค่าตัวแปร ในกรณีของตัวแปรเดียว จะถูกกำหนดค่า
ไม่มี; มิฉะนั้นจะใช้ค่าที่ให้มา

=> (ให้ [x [y 5]] (พิมพ์ xy))
ไม่มี5

รายการเปรียบเทียบ
รายการเปรียบเทียบ ดำเนินการทำความเข้าใจรายการ ใช้พารามิเตอร์สองหรือสามตัว ครั้งแรก
พารามิเตอร์คือนิพจน์ที่ควบคุมค่าที่ส่งกลับในขณะที่ค่าที่สองใช้เพื่อ
เลือกรายการจากรายการ พารามิเตอร์ที่สามและเป็นทางเลือกสามารถใช้เพื่อกรองบางส่วนได้
ของรายการในรายการตามนิพจน์เงื่อนไข ตัวอย่างบางส่วน:

=> (การรวบรวม def (ช่วง 10))
=> (list-comp x [x collection])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=> (list-comp (* x 2) [x collection])
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

=> (list-comp (* x 2) [x collection] (< x 5))
[0, 2, 4, 6, 8]

ไม่
ไม่ ใช้ในนิพจน์เชิงตรรกะ ใช้พารามิเตอร์ตัวเดียวและส่งกลับค่าที่กลับกัน
ค่าความจริง ถ้า จริง ถูกกำหนดเป็นพารามิเตอร์ เท็จ จะถูกส่งกลับและในทางกลับกัน
ตัวอย่างการใช้งาน:

=> (ไม่จริง)
เท็จ

=> (ไม่ใช่เท็จ)
จริง

=> (ไม่ใช่ไม่มี)
จริง

or
or ใช้ในนิพจน์เชิงตรรกะ ต้องใช้อย่างน้อยสองพารามิเตอร์ มันจะส่งคืน
พารามิเตอร์ที่ไม่เป็นเท็จตัวแรก หากไม่มีค่าดังกล่าว พารามิเตอร์สุดท้ายจะถูกส่งคืน

=> (หรือ จริง เท็จ)
จริง

=> (และเท็จเท็จ)
เท็จ

=> (และเท็จ 1 จริงเท็จ)
1

หมายเหตุ:
or ลัดวงจรและหยุดการประเมินพารามิเตอร์ทันทีที่ค่าจริงตัวแรกคือ
ได้พบเจอ

=> (หรือ True (พิมพ์ "สวัสดี"))
จริง

พิมพ์
พิมพ์ ใช้สำหรับส่งออกบนหน้าจอ ตัวอย่างการใช้งาน:

(พิมพ์ "สวัสดีชาวโลก!")

หมายเหตุ:
พิมพ์ กลับมาเสมอ ไม่มี.

อ้างสิทธิ์
อ้างสิทธิ์ อนุญาตให้คุณอ้างอิงแบบฟอร์ม แต่ยังเลือกประเมินนิพจน์ด้วย
นิพจน์ภายใน a อ้างสิทธิ์ สามารถเลือกประเมินได้โดยใช้ ไม่ได้นำมาอ้าง (~)
แบบฟอร์มที่ประเมินแล้วยังสามารถประกบกันโดยใช้ unquote-ประกบ (~@). Quasiquote สามารถยัง
เขียนโดยใช้ backquot (`) เครื่องหมาย.

;; ให้ `qux' เป็นตัวแปรที่มีค่า (bar baz)
`(ฟู~คูกซ์)
; เทียบเท่ากับ '(foo (bar baz))
`(ฟู~@qux)
; เทียบเท่ากับ '(foo bar baz)

หุ้น
หุ้น ส่งคืนแบบฟอร์มที่ส่งไปโดยไม่ประเมิน หุ้น สามารถ
เขียนโดยใช้เครื่องหมายอะพอสทรอฟี (') เครื่องหมาย.

=> (setv x '(พิมพ์ "สวัสดีชาวโลก"))
; ตัวแปร x ถูกตั้งค่าเป็นนิพจน์ & ไม่ได้รับการประเมิน
=> x
(u'print' u'Hello World')
=> (eval x)
สวัสดีชาวโลก

ต้องการ
ต้องการ ใช้เพื่อนำเข้ามาโครจากโมดูลที่กำหนด ต้องใช้อย่างน้อยหนึ่งพารามิเตอร์
การระบุโมดูลที่ควรนำเข้ามาโคร สามารถนำเข้าหลายโมดูลได้
ด้วยไฟล์ ต้องการ.

ตัวอย่างต่อไปนี้จะนำเข้ามาโครจาก โมดูล-1 และ โมดูล-2:

(ต้องใช้โมดูล-1 โมดูล-2)

ส่วนที่เหลือ / ผบ
ส่วนที่เหลือ และ ผบ ส่งคืนคอลเลกชันที่ส่งผ่านเป็นอาร์กิวเมนต์โดยไม่มีองค์ประกอบแรก:

=> (พัก (ช่วง 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

ชุดคอมพ์
ชุดคอมพ์ ใช้ในการสร้างชุด ใช้พารามิเตอร์สองหรือสามตัว พารามิเตอร์แรกคือ
เพื่อควบคุมมูลค่าที่ส่งกลับ ในขณะที่อันที่สองใช้สำหรับเลือกรายการจาก a
ลำดับ. พารามิเตอร์ที่สามและเป็นทางเลือกสามารถใช้เพื่อกรองบางรายการใน
ลำดับตามนิพจน์เงื่อนไข

=> (ข้อมูล setv [1 2 3 4 5 2 3 4 5 3 4 5])
=> (set-comp x [x data] (คี่? x))
{1, 3, 5}

ฝาน
ฝาน สามารถใช้เพื่อดึงชุดย่อยของรายการและสร้างรายการใหม่ได้ แบบฟอร์ม
ใช้เวลาอย่างน้อยหนึ่งพารามิเตอร์ที่ระบุรายการที่จะแบ่ง สามารถเลือกพารามิเตอร์เสริมได้ XNUMX ตัว
ใช้กำหนดตำแหน่งเริ่มต้นและสิ้นสุดของเซตย่อย หากไม่มีการจัดหาให้
ค่าเริ่มต้นของ ไม่มี จะใช้แทน พารามิเตอร์ทางเลือกที่สามใช้เพื่อ
ควบคุมขั้นตอนระหว่างองค์ประกอบ

ฝาน ทำตามกฎเดียวกันกับ Python นับดัชนีติดลบ
เริ่มจากท้ายรายการ ตัวอย่างการใช้งาน:

=> (การรวบรวม def (ช่วง 10))

=> (คอลเลกชันสไลซ์)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=> (ชุดสไลซ์ 5)
[5, 6, 7, 8, 9]

=> (ชุดสไลซ์ 2 8)
[2, 3, 4, 5, 6, 7]

=> (ชุดสไลซ์ 2 8 2)
[2, 4, 6]

=> (คอลเลกชันสไลซ์ -4 -2)
[6, 7]

โยน / ยก
พื้นที่ โยน or ยก แบบฟอร์มสามารถใช้เพื่อเพิ่ม an ข้อยกเว้น ที่รันไทม์ ตัวอย่างการใช้งาน:

(โยน)
; ยกข้อยกเว้นล่าสุดอีกครั้ง

(โยน IOError)
; โยน IOError

(โยน (IOError "foobar"))
; โยน IOError ("foobar")

โยน สามารถยอมรับอาร์กิวเมนต์เดียวได้ (an ข้อยกเว้น คลาสหรืออินสแตนซ์) หรือไม่มีอาร์กิวเมนต์ถึง
เพิ่มครั้งสุดท้าย ข้อยกเว้น.

ลอง
พื้นที่ ลอง แบบฟอร์มใช้เพื่อเริ่มต้น a ลอง / จับ บล็อก. ใช้แบบฟอร์มดังนี้:

(ลอง
(ฟังก์ชันที่มีแนวโน้มผิดพลาด)
(จับ [e ZeroDivisionError] (พิมพ์ "หารด้วยศูนย์"))
(อย่างอื่น (พิมพ์ว่า "ไม่มีข้อผิดพลาด"))
(สุดท้าย (พิมพ์ "เสร็จสิ้น")))

ลอง ต้องมีอย่างน้อยหนึ่ง จับ บล็อกและอาจรวม an อื่น or ในที่สุด
บล็อก. หากเกิดข้อผิดพลาดขึ้นพร้อมกับบล็อก catch ที่ตรงกันระหว่างการดำเนินการของ
ฟังก์ชันที่มีแนวโน้มผิดพลาดที่ จับ บล็อกจะถูกดำเนินการ หากไม่มีข้อผิดพลาดเกิดขึ้น อื่น
บล็อกถูกดำเนินการ ดิ ในที่สุด บล็อกจะถูกดำเนินการครั้งสุดท้ายไม่ว่า an . หรือไม่
เกิดข้อผิดพลาดขึ้น

เว้นแต่
พื้นที่ เว้นแต่ มาโครเป็นชวเลขสำหรับเขียน an if คำสั่งที่ตรวจสอบว่าได้รับ
เงื่อนไขคือ เท็จ. ต่อไปนี้แสดงการขยายของมาโครนี้

(เว้นแต่เป็นคำสั่งแบบมีเงื่อนไข)

(ถ้าเงื่อนไข
ไม่มี
(ทำคำสั่ง))

ไม่ได้นำมาอ้าง
ภายในแบบฟอร์มเสมือน ไม่ได้นำมาอ้าง การประเมินกำลังของสัญลักษณ์ ไม่ได้นำมาอ้าง มีนามแฝงว่า
ตัวหนอน (~) เครื่องหมาย.

(ชื่อเดิม "กอด")
(quasiquote (= ชื่อ (ชื่อที่ไม่มีเครื่องหมายคำพูด)))
;=> (u'=' u'name' u'Cuddles')

`(= ชื่อ ~ชื่อ)
;=> (u'=' u'name' u'Cuddles')

unquote-ประกบ
unquote-ประกบ บังคับให้มีการประเมินสัญลักษณ์ในรูปแบบ quasiquoted เช่น
ไม่ได้นำมาอ้าง. unquote-ประกบ ใช้ได้เฉพาะเมื่อสัญลักษณ์ที่ไม่มีเครื่องหมายอัญประกาศมี an
ค่าที่ทำซ้ำได้ เนื่องจาก "ประกบ" ที่วนซ้ำได้ในรูปแบบกึ่งควอซิโควต unquote-ประกบ is
นามแฝงว่า ~@ สัญลักษณ์.

(ตัวเลข def [1 2 3 4])
(quasiquote (+ (unquote-splice nums)))
;=> (u'+' 1L 2L 3L 4L)

`(+ ~@จำนวน)
;=> (u'+' 1L 2L 3L 4L)

เมื่อ
เมื่อ มีความคล้ายคลึงกับ เว้นแต่เว้นแต่จะทดสอบว่าเงื่อนไขที่กำหนดคือ จริง. มันไม่ใช่
เป็นไปได้ที่จะมี อื่น บล็อกใน a เมื่อ มาโคร ต่อไปนี้แสดงการขยายตัวของ
แมโคร

(เมื่อคำสั่งแบบมีเงื่อนไข)

(ถ้ามีเงื่อนไข (คำสั่ง do))

ในขณะที่
ในขณะที่ ใช้เพื่อดำเนินการหนึ่งบล็อกขึ้นไปตราบเท่าที่ตรงตามเงื่อนไข ต่อไปนี้
ตัวอย่างจะส่งออก "สวัสดีชาวโลก!" ไปที่หน้าจออย่างไม่มีกำหนด:

(ในขณะที่ทรู (พิมพ์ "สวัสดีชาวโลก!"))

กับ
กับ ใช้เพื่อห่อการดำเนินการของบล็อกภายในตัวจัดการบริบท บริบท
ผู้จัดการสามารถตั้งค่าระบบท้องถิ่นและทำลายมันในลักษณะที่ควบคุมได้ ดิ
ตัวอย่างต้นแบบของการใช้ กับ คือเมื่อประมวลผลไฟล์ กับ สามารถผูกบริบทกับ an
อาร์กิวเมนต์หรือละเว้นอย่างสมบูรณ์ดังแสดงด้านล่าง:

(ด้วย [[arg (expr)]] บล็อก)

(ด้วย [[(expr)]] บล็อก)

(ด้วย [[arg (expr)] [(expr)]] บล็อก)

ตัวอย่างต่อไปนี้จะเปิด ข่าว（NEWS） ไฟล์และพิมพ์เนื้อหาไปยังหน้าจอ ดิ
ไฟล์จะถูกปิดโดยอัตโนมัติหลังจากประมวลผลแล้ว

(ด้วย [[f (เปิด "NEWS")]] (พิมพ์ (.read f)))

พร้อมมัณฑนากร
พร้อมมัณฑนากร ใช้ในการห่อฟังก์ชันด้วยฟังก์ชันอื่น ฟังก์ชันที่ทำหน้าที่
การตกแต่งควรยอมรับค่าเดียว: ฟังก์ชั่นการตกแต่งและคืนค่าใหม่
ฟังก์ชัน พร้อมมัณฑนากร รับอย่างน้อยสองพารามิเตอร์: ฟังก์ชันที่ดำเนินการ
การตกแต่งและฟังก์ชั่นการตกแต่ง ฟังก์ชันมัณฑนากรได้มากกว่าหนึ่งฟังก์ชัน
สมัครแล้ว; พวกเขาจะนำไปใช้ในการสั่งซื้อจากนอกสุดไปในสุดคือ คนแรก
มัณฑนากรจะเป็นคนที่อยู่นอกสุดเป็นต้น มัณฑนากรที่มีการโต้แย้งเรียกว่าเพียง
เช่นการเรียกใช้ฟังก์ชัน

(มี-มัณฑนากร-สนุก
(defn บางฟังก์ชั่น [] ...)

(พร้อม-มัณฑนากร1 มัณฑนากร2 ...
(defn บางฟังก์ชั่น [] ...)

(มี-มัณฑนากร(มัณฑนากร) ..
(defn บางฟังก์ชั่น [] ...)

ในตัวอย่างต่อไปนี้ inc-มัณฑนากร ใช้สำหรับตกแต่งฟังก์ชั่น นอกจากนี้ กับ
ฟังก์ชั่นที่รับสองพารามิเตอร์และเรียกใช้ฟังก์ชั่นที่ตกแต่งด้วยค่าที่
เพิ่มขึ้น 1 เมื่อตกแต่ง นอกจากนี้ ถูกเรียกด้วยค่า 1 และ 1 สิ้นสุด
ผลลัพธ์จะเป็น 4 (1 + 1 + 1 + 1).

=> (defn inc-มัณฑนากร [func]
... (fn [ค่า-1 ค่า-2] (ฟังก์ชัน (+ ค่า-1 1) (+ ค่า-2 1))))
=> (defn inc2-มัณฑนากร [func]
... (fn [ค่า-1 ค่า-2] (ฟังก์ชัน (+ ค่า-1 2) (+ ค่า-2 2))))

=> (พร้อมมัณฑนากร inc-decorator (defn นอกเหนือจาก [ab] (+ ab)))
=> (เพิ่มเติม 1 1)
4
=> (พร้อม-มัณฑนากร inc2-มัณฑนากร inc-มัณฑนากร
... (defn เพิ่ม [ab] (+ ab)))
=> (เพิ่มเติม 1 1)
8

กับ-gensyms
ใหม่ในเวอร์ชัน 0.9.12

กับ-gensym ใช้ในการสร้างชุดของ เจนซิม เพื่อใช้ในมาโคร รหัสต่อไปนี้:

(ด้วย-gensyms [abc]
... )

ขยายเป็น:

(ให้ [[a (gensym))
[b (จีซิม)
[ค (เจนซิม)]]
... )

SEE เพิ่มเติม:
ส่วนใช้-gensym

ผล
ผล ใช้เพื่อสร้างวัตถุตัวสร้างที่ส่งกลับค่าหนึ่งค่าขึ้นไป เครื่องกำเนิดไฟฟ้า
สามารถทำซ้ำได้ดังนั้นจึงสามารถใช้ในลูป รายการความเข้าใจ และอื่นๆ ที่คล้ายคลึงกัน
โครงสร้าง

ฟังก์ชั่น สุ่มตัวเลข แสดงให้เห็นว่าเครื่องกำเนิดไฟฟ้าสามารถใช้สร้างอนุกรมอนันต์ได้อย่างไร
โดยไม่ต้องใช้หน่วยความจำจำนวนอนันต์

=> (defn คูณ [ค่าสัมประสิทธิ์ฐาน]
... (สำหรับ [[(, สัมประสิทธิ์ฐาน) (สัมประสิทธิ์ฐานไปรษณีย์)]]
... (ผลผลิต (* ค่าสัมประสิทธิ์ฐาน))))

=> (คูณ (ช่วง 5) (ช่วง 5))


=> (ค่า list-comp [ค่า (คูณ (ช่วง 10)) (ช่วง 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (นำเข้าแบบสุ่ม)
=> (defn สุ่มตัวเลข [ต่ำสูง]
... (ในขณะที่ True (ผลตอบแทน (.randint สุ่มต่ำสูง))))
=> (list-comp 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 AND UP เท่านั้น!

ผลผลิตจาก ใช้เพื่อเรียก subgenerator สิ่งนี้มีประโยชน์หากคุณต้องการให้คอร์รูทีนของคุณทำ
สามารถมอบหมายกระบวนการของมันให้กับ coroutine อื่นได้เช่นถ้าใช้สิ่งที่แฟนซีเช่น
อะซินซิโอ.

Hy แกน
แกน ฟังก์ชั่น
สุดท้าย
การใช้งาน: (แต่สุดท้าย คอล)

ส่งกลับตัววนซ้ำทั้งหมดยกเว้นรายการสุดท้ายใน Coll.

=> (รายการ (butlast (ช่วง 10))))
[0, 1, 2, 3, 4, 5, 6, 7, 8]

=> (รายการ (butlast [1]))
[]

=> (รายการ (butlast []))
[]

=> (นำเข้า itertools)
=> (รายการ (ใช้เวลา 5 (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

คอล?
ใหม่ในเวอร์ชัน 0.10.0

การใช้งาน: (คอล? x)

คืนสินค้า จริง if x เป็นแบบวนซ้ำได้และไม่ใช่สตริง

=> (คอล? [1 2 3 4])
จริง

=> (คอล? {"a" 1 "b" 2})
จริง

=> (คอล? "เอบีซี")
เท็จ

ข้อเสีย
ใหม่ในเวอร์ชัน 0.10.0

การใช้งาน: (ข้อเสีย a b)

คืนเซลล์ข้อเสียใหม่พร้อมรถยนต์ a และ cdr b.

=> (setv a (ข้อเสีย 'hd 'tl))

=> (= 'hd (รถ a))
จริง

=> (= 'tl (cdr a))
จริง

ข้อเสีย?
ใหม่ในเวอร์ชัน 0.10.0

การใช้งาน: (ข้อเสีย? ฟู)

ตรวจสอบว่า foo เป็นเซลล์ข้อเสีย

=> (setv a (ข้อเสีย 'hd 'tl))

=> (ข้อเสีย? ก)
จริง

=> (ข้อเสีย? ไม่มี)
เท็จ

=> (ข้อเสีย? [1 2 3])
เท็จ

ธันวาคม
การใช้งาน: (ธ.ค x)

ส่งกลับน้อยกว่า x. เทียบเท่ากับ (- x 1). เพิ่ม ประเภทข้อผิดพลาด if (ยังไม่ (ตัวเลข? เอ็กซ์)).

=> (วันที่ 3)
2

=> (วันที่ 0)
-1

=> (วันที่ 12.3)
11.3

ถอดแยกชิ้นส่วน
ใหม่ในเวอร์ชัน 0.10.0

การใช้งาน: (ถอดประกอบ ต้นไม้ &ไม่จำเป็น [โคเดเจน เท็จ])

ทิ้ง Python AST สำหรับ Hy . ที่กำหนด ต้นไม้ สู่เอาต์พุตมาตรฐาน ถ้า โคเดเจน is จริง, ฟังก์ชั่น
พิมพ์รหัส Python แทน

=> (ถอดแยกชิ้นส่วน '(พิมพ์ "สวัสดีชาวโลก!"))
โมดูล(
ร่างกาย=[
Expr(value=Call(func=Name(id='print'), args=[Str(s='Hello World!')], คีย์เวิร์ด=[], starargs=None, kwargs=None))])

=> (ถอดแยกชิ้นส่วน '(พิมพ์ "สวัสดีชาวโลก!") จริง)
พิมพ์('สวัสดีชาวโลก!')

ว่างเปล่า?
การใช้งาน: (ว่างเปล่า? คอล)

คืนสินค้า จริง 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]

Inc
การใช้งาน: (รวม x)

ส่งกลับมากกว่า x. เทียบเท่ากับ (+ x 1). เพิ่ม ประเภทข้อผิดพลาด if (ยังไม่ (ตัวเลข? เอ็กซ์)).

=> (รวม 3)
4

=> (รวม 0)
1

=> (รวม 12.3)
13.3

ตัวอย่าง?
การใช้งาน: (ตัวอย่าง? ชั้น x)

คืนสินค้า จริง if x เป็นตัวอย่างของ ชั้น.

=> (ตัวอย่าง? float 1.0)
จริง

=> (ตัวอย่าง? int 7)
จริง

=> (ตัวอย่าง? str (str "foo"))
จริง

=> (defclass TestClass [วัตถุ])
=> (ชุด setv (TestClass))
=> (อินสแตนซ์? อินสแตนซ์ TestClass)
จริง

จำนวนเต็ม?
การใช้งาน: (จำนวนเต็ม? x)

คืนสินค้า จริง if x เป็นจำนวนเต็ม สำหรับ Python 2 นี่ก็คือ int or ยาว. สำหรับไพธอน 3
นี้คือ int.

=> (จำนวนเต็ม? 3)
จริง

=> (จำนวนเต็ม? -2.4)
เท็จ

สอดแทรก
ใหม่ในเวอร์ชัน 0.10.1

การใช้งาน: (อินเตอร์ลีฟ ลำดับที่ 1 ลำดับที่ 2 ... )

ส่งกลับรายการแรกที่ทำซ้ำได้ในแต่ละลำดับ จากนั้นเป็นรายการที่สอง ฯลฯ

=> (รายการ (อินเตอร์ลีฟ (ช่วง 5) (ช่วง 100 105)))
[0, 100, 1, 101, 2, 102, 3, 103, 4, 104]

=> (รายการ (อินเตอร์ลีฟ (ช่วง 1000000) "abc"))
[0, 'a', 1, 'b', 2, 'c']

ขวาง
ใหม่ในเวอร์ชัน 0.10.1

การใช้งาน: (อินเตอร์โพส ชิ้น ลำดับ)

ส่งคืนองค์ประกอบที่ทำซ้ำได้ของลำดับที่คั่นด้วยรายการ

=> (รายการ (คั่น "!" "abcd"))
['เอบีซีดี']

=> (รายการ (อินเตอร์โพส -1 (ช่วง 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

ทำซ้ำได้?
การใช้งาน: (ซ้ำซาก? x)

คืนสินค้า จริง if x สามารถทำซ้ำได้ วัตถุที่ทำซ้ำได้จะส่งคืนตัววนซ้ำใหม่เมื่อ (อิเตอร์ x) is
เรียกว่า. ตรงกันข้ามกับ ตัววนซ้ำ?.

=> ;; ใช้งานได้กับเครื่องสาย
=> ( iterable? (str "abcde"))
จริง

=> ;; ทำงานให้กับรายการ
=> (ทำซ้ำได้? [1 2 3 4 5])
จริง

=> ;; ทำงานเพื่อทูเพิล
=> (ทำซ้ำได้? (, 1 2 3))
จริง

=> ;; ทำงานเพื่อ dicts
=> (ทำซ้ำได้? {:a 1 :b 2 :c 3})
จริง

=> ;; ใช้ได้กับ iterators/เครื่องกำเนิดไฟฟ้า
=> (ซ้ำได้ไหม? (ซ้ำ 3))
จริง

ตัววนซ้ำ?
การใช้งาน: (ตัววนซ้ำ? x)

คืนสินค้า จริง if x เป็นตัววนซ้ำ ตัววนซ้ำเป็นวัตถุที่ส่งคืนตัวเองเป็น
วนซ้ำเมื่อ (อิเตอร์ x) ถูกเรียก. ตรงกันข้ามกับ ทำซ้ำได้?.

=> ;; ใช้ไม่ได้กับรายการ
=> (ตัววนซ้ำ? [1 2 3 4 5])
เท็จ

=> ;; แต่เราสามารถรับ iter จากรายการ
=> (ตัววนซ้ำ? (iter [1 2 3 4 5]))
จริง

=> ;; ไม่ทำงานสำหรับ dict
=> (ตัววนซ้ำ? {:a 1 :b 2 :c 3})
เท็จ

=> ;; สร้างตัววนซ้ำจาก dict
=> (ตัววนซ้ำ? (iter {:a 1 :b 2 :c 3}))
จริง

รายการ*
การใช้งาน: (รายการ* หัว &พักผ่อน หาง)

สร้างห่วงโซ่ของเซลล์ข้อเสียที่ซ้อนกัน (รายการจุด) ที่มีอาร์กิวเมนต์ ถ้า
รายการอาร์กิวเมนต์มีองค์ประกอบเดียวเท่านั้น ส่งคืน

=> (รายการ* 1 2 3 4)
(1 2 3 . 4)

=> (รายการ* 1 2 3 [4])
[1, 2, 3, 4]

=> (รายการ* 1)
1

=> (ข้อเสีย? (รายการ* 1 2 3 4))
จริง

มาโครขยาย
ใหม่ในเวอร์ชัน 0.10.0

การใช้งาน: (มาโครขยาย แบบฟอร์ม)

ส่งกลับการขยายมาโครแบบเต็มของ ฟอร์ม.

=> (macroexpand '(-> (ab) (xy)))
(u'x' (u'a' u'b') u'y')

=> (macroexpand '(-> (ab) (-> (cd) (ef))))
(u'e' (u'c' (u'a' u'b') u'd') u'f')

มาโครขยาย-1
ใหม่ในเวอร์ชัน 0.10.0

การใช้งาน: (มาโครขยาย-1 แบบฟอร์ม)

ส่งกลับการขยายมาโครขั้นตอนเดียวของ ฟอร์ม.

=> (macroexpand-1 '(-> (ab) (-> (cd) (ef))))
(u'_>' (u'a' u'b') (u'c' u'd') (u'e' u'f'))

ผสานกับ
ใหม่ในเวอร์ชัน 0.10.1

การใช้งาน: (ผสานกับ f &พักผ่อน แผนที่)

ส่งคืนแผนที่ที่ประกอบด้วยแผนที่ที่เหลือที่เชื่อมติดกันก่อน หากคีย์เกิดขึ้นใน
มากกว่าหนึ่งแผนที่ การแมปจากหลัง (จากซ้ายไปขวา) จะถูกรวมเข้ากับ
การทำแผนที่ในผลลัพธ์โดยการโทร (f val-in-ผลลัพธ์ วาลหลัง).

=> (ผสานกับ (fn [xy] (+ xy)) {"a" 10 "b" 20} {"a" 1 "c" 30})
{คุณ: 11L คุณ: 30L คุณ: 20L}

ปฏิเสธ?
การใช้งาน: (เปล่า? x)

คืนสินค้า จริง if x มีค่าน้อยกว่าศูนย์ เพิ่ม ประเภทข้อผิดพลาด if (ยังไม่ (ตัวเลข? เอ็กซ์)).

=> (ไม่? -2)
จริง

=> (ไม่? 3)
เท็จ

=> (ไม่? 0)
เท็จ

ไม่มี?
การใช้งาน: (ไม่มี? x)

คืนสินค้า จริง if x is ศูนย์ / ไม่มี.

=> (ไม่มี? ไม่มี)
จริง

=> (ไม่มี? ไม่มี)
จริง

=> (ไม่มี? 0)
เท็จ

=> (setf x ไม่มี)
=> (ไม่มี? x)
จริง

=> ;; list.append จะคืนค่า None . เสมอ
=> (ไม่มี? (.append [1 2 3] 4))
จริง

ไม่มี?
การใช้งาน: (ไม่มี? x)

คืนสินค้า จริง if x is ไม่มี.

=> (ไม่มี? ไม่มี)
จริง

=> (ไม่มี? 0)
เท็จ

=> (setf x ไม่มี)
=> (ไม่มี? x)
จริง

=> ;; list.append จะคืนค่า None . เสมอ
=> (ไม่มี? (.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)
Traceback (โทรล่าสุดล่าสุด):
...
ValueError: ดัชนีสำหรับ islice() ต้องเป็น None หรือจำนวนเต็ม: 0 <= x <= sys.maxsize

ตัวเลข?
การใช้งาน: (ตัวเลข? x)

คืนสินค้า จริง if x เป็นตัวเลขตามที่กำหนดไว้ใน Python's ตัวเลขจำนวน ชั้นเรียน

=> (ตัวเลข? -2)
จริง

=> (ตัวเลข? 3.2)
จริง

=> (ตัวเลข? "foo")
เท็จ

odd?
การใช้งาน: (แปลก? 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 เป็นสตริง

=> (สตริง? "foo")
จริง

=> (สตริง? -2)
เท็จ

สัญลักษณ์?
การใช้งาน: (สัญลักษณ์? x)

คืนสินค้า จริง if x เป็นสัญลักษณ์

=> (สัญลักษณ์? 'foo)
จริง

=> (สัญลักษณ์? '[abc])
เท็จ

ศูนย์?
การใช้งาน: (ศูนย์? x)

คืนสินค้า จริง if x เป็นศูนย์

=> (ศูนย์? 3)
เท็จ

=> (ศูนย์? -2)
เท็จ

=> (ศูนย์? 0)
จริง

ลำดับ ฟังก์ชั่น
ฟังก์ชันซีเควนซ์สามารถสร้างหรือดำเนินการบนลำดับอนันต์ที่อาจเกิดขึ้นได้โดยไม่ต้องใช้
ต้องใช้ลำดับที่รับรู้อย่างสมบูรณ์ในรายการหรือคอนเทนเนอร์ที่คล้ายกัน พวกเขาทำสิ่งนี้โดย
ส่งคืน Python iterator

เราสามารถใช้ตัวสร้างตัวเลขฟีโบนักชีอนันต์ตามบัญญัติเป็นตัวอย่างของวิธีใช้
บางส่วนของฟังก์ชันเหล่านี้

(defn ตอแหล []
(เซ็ตเอ 0)
(เซ็ตบี 1)
(ในขณะที่จริง
(ให้ผลก)
(setv (, ab) (, b (+ ab)))))

หมายเหตุ (ในขณะที่ จริง ... ) ห่วง ถ้าเราเรียกใช้สิ่งนี้ใน REPL

=> (ปิ๊ง)


การเรียกใช้ฟังก์ชันจะคืนค่าตัววนซ้ำเท่านั้น แต่จะไม่ทำงานจนกว่าเราจะใช้งาน
ไม่แนะนำให้ลองแบบนี้เพราะวนไม่สิ้นสุดจะทำงานจนกว่าจะถึง
ใช้ RAM ที่มีอยู่ทั้งหมดหรือในกรณีนี้จนกว่าฉันจะฆ่ามัน

=> (รายการ (fib))
[1] 91474 ฆ่า hy

เพื่อให้ได้ตัวเลขฟีโบนักชี 10 ตัวแรก ให้ใช้ เอา. สังเกตได้ว่า เอา ยังส่งคืนเครื่องกำเนิด
ดังนั้นฉันจึงสร้างรายการจากมัน

=> (รายการ (เอา 10 (fib))))
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

ในการรับหมายเลขฟีโบนักชีที่ดัชนี 9 (เริ่มจาก 0):

=> (nth (fib) 9)
34

วงจร
การใช้งาน: (รอบ คอล)

ส่งกลับตัววนซ้ำอนันต์ของสมาชิกของ coll

=> (รายการ (ใช้เวลา 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]

=> (รายการ (แตกต่าง []))
[]

=> (รายการ (แตกต่าง (iter [ 1 2 3 4 3 5 2 ])))
[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 ไม่มี "a"])))
[ไม่มี u'a']

=> (รายการ (วางขณะ pos? [2 4 7 8 9]))
[]

กรอง
การใช้งาน: (กรอง เพรด คอล)

ส่งคืนตัววนซ้ำสำหรับรายการทั้งหมดใน Coll ที่ผ่านกริยา เพรด.

ดูสิ่งนี้ด้วย เอาออก.

=> (รายการ (ตัวกรอง pos? [1 2 3 -4 5 -7]))
[1, 2, 3, 5]

=> (รายการ (กรองคู่? [1 2 3 -4 5 -7]))
[2, -4]

เรียบ
ใหม่ในเวอร์ชัน 0.9.12

การใช้งาน: (เรียบ คอล)

ส่งกลับรายการเดียวของรายการทั้งหมดใน Coll, โดยแบนรายการที่มีอยู่ทั้งหมดและ/หรือ
สิ่งอันดับ

=> (แบน [1 2 [3 4] 5])
[1, 2, 3, 4, 5]

=> (แบน ["foo" (, 1 2) [1 [2 3] 4] "bar"])
['foo', 1, 2, 1, 2, 3, 4, 'บาร์']

ย้ำ
การใช้งาน: (ย้ำ fn x)

ส่งกลับตัววนซ้ำของ x, ฟน(x), เอฟเอ็น(เอฟเอ็น(x))ฯลฯ

=> (รายการ (ใช้เวลา 5 (วนซ้ำ inc 5)))
[5, 6, 7, 8, 9]

=> (รายการ (ใช้เวลา 5 (วนซ้ำ (fn [x] (* xx)) 5)))
[5, 25, 625, 390625, 152587890625]

อ่าน
การใช้งาน: (อ่าน &ไม่จำเป็น [จากไฟล์ อ๊อฟ])

อ่านนิพจน์ Hy ถัดไปจาก จากไฟล์ (ค่าเริ่มต้นเป็น sys.stdin) และสามารถรับ a
ไบต์เดียวเป็น EOF (ค่าเริ่มต้นเป็นสตริงว่าง) เพิ่ม EOFข้อผิดพลาด if จากไฟล์ สิ้นสุดก่อน
สามารถแยกวิเคราะห์นิพจน์ที่สมบูรณ์ได้

=> (อ่าน)
(+ 2 2)
('+' 2 2)
=> (ประเมิน (อ่าน))
(+ 2 2)
4

=> (นำเข้า io)
=> (บัฟเฟอร์ def (io.StringIO "(+ 2 2)\n(- 2 1)"))
=> (eval (ใช้ read [] {"from_file" buffer}))
4
=> (eval (ใช้ read [] {"from_file" buffer}))
1

=> ; สมมติว่า "example.hy" ประกอบด้วย:
=> ; (พิมพ์ "สวัสดี")
=> ; (พิมพ์ "hyfriends!")
=> (ด้วย [[f (เปิด "example.hy")]]
... (ลอง
... (ในขณะที่จริง
... (ให้ [[exp (อ่าน f)]]
... (ทำ
... (พิมพ์ "OHY" exp)
... (ประเมินประสบการณ์))))
... (จับ [e EOFError]
... (พิมพ์ "EOF!"))))
OHY ('พิมพ์' 'สวัสดี')
สวัสดี
OHY ('พิมพ์' 'hyfriends!')
เพื่อน!
อีฟ!

เอาออก
การใช้งาน: (ลบ เพรด คอล)

ส่งกลับตัววนซ้ำจาก Coll ด้วยองค์ประกอบที่ผ่านภาคแสดง เพรด, ลบออก.

ดูสิ่งนี้ด้วย กรอง.

=> (รายการ (ลบคี่? [1 2 3 4 5 6 7]))
[2, 4, 6]

=> (รายการ (ลบ pos? [1 2 3 4 5 6 7]))
[]

=> (รายการ (ลบ neg? [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 คอล)

ส่งกลับตัววนซ้ำที่มี first n สมาชิกของ Coll. เพิ่ม ค่าข้อผิดพลาด if n is
เชิงลบ

=> (รายการ (เอา 3 [1 2 3 4 5]))
[1, 2, 3]

=> (รายการ (ใช้ 4 (ซ้ำ "s")))
[คุณ คุณ คุณ คุณ]

=> (รายการ (ใช้ 0 (ซ้ำ "s")))
[]

ใช้เวลาที่ n
การใช้งาน: (ใช้เวลา-n n คอล)

ส่งกลับตัววนซ้ำที่มีทุก n- สมาชิกคนที่ Coll.

=> (รายการ (ข้อที่ 2 [1 2 3 4 5 6 7]))
[1, 3, 5, 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 ตราบใดที่ เพรด รับคืน จริง.

=> (รายการ (ใช้ขณะ pos? [ 1 2 3 -4 5]))
[1, 2, 3]

=> (รายการ (ใช้เวลาสักครู่หรือไม่ [ -4 -3 1 2 5]))
[-4, -3]

=> (รายการ (ใช้เวลาสักครู่หรือไม่ [ 1 2 3 -4 5]))
[]

ซิปด้วย
ใหม่ในเวอร์ชัน 0.9.13

การใช้งาน: (ซิปด้วย fn Coll ... )

เทียบเท่ากับ ไปรษณีย์แต่ใช้ฟังก์ชันหลายอาร์กิวเมนต์แทนการสร้างทูเพิล ถ้า
ซิปด้วย ถูกเรียกด้วยคอลเลกชัน N แล้ว fn ต้องยอมรับอาร์กิวเมนต์ N

=> (ผู้ประกอบการนำเข้า)
=> (รายการ (zip พร้อมตัวดำเนินการเพิ่ม [1 2 3] [4 5 6]))
[5, 7, 9]

ผู้อ่าน แมโคร
มาโครตัวอ่านช่วยให้ Lisp สามารถปรับเปลี่ยนและปรับเปลี่ยนรูปแบบได้ทันที คุณไม่ต้องการ
สัญกรณ์โปแลนด์? มาโครตัวอ่านสามารถทำได้อย่างง่ายดาย ต้องการวิธีการของ Clojure ในการมี
regex? มาโครตัวอ่านสามารถทำสิ่งนี้ได้อย่างง่ายดายเช่นกัน

วากยสัมพันธ์
=> (defreader ^ [expr] (พิมพ์ expr))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"สวัสดี"
"สวัสดี"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

Hy ไม่มีตัวอักษรสำหรับทูเพิล ให้บอกว่าไม่ชอบ (, ... ) และต้องการอย่างอื่น นี้
เป็นมาโครตัวอ่านปัญหาที่สามารถแก้ไขได้อย่างเรียบร้อย

=> (defreader t [expr] `(, ~@expr))
=> #t(1 2 3)
(1, 2, 3)

คุณสามารถทำได้เหมือน Clojure และมีตัวอักษรสำหรับนิพจน์ทั่วไป!

=> (นำเข้าอีกครั้ง)
=> (defreader r [expr] `(re.compile ~ expr))
=> #r".*"
<_sre.SRE_Pattern วัตถุที่ 0xcv7713ph15#>

การดำเนินงาน
ผู้ทำลาย ใช้อักขระตัวเดียวเป็นชื่อสัญลักษณ์สำหรับมาโครตัวอ่าน อะไรอีกต่อไป
จะส่งคืนข้อผิดพลาด การดำเนินการอย่างชาญฉลาด, ผู้ทำลาย ขยายเป็นแลมบ์ดาที่ปกคลุมไปด้วย
มัณฑนากร มัณฑนากรนี้บันทึกแลมบ์ดาในพจนานุกรมด้วยชื่อโมดูลและ
สัญลักษณ์.

=> (defreader ^ [expr] (พิมพ์ expr))
;=> (with_decorator (hy.macros.reader ^) (fn [expr] (พิมพ์ expr)))

# ขยายเป็น (dispatch_reader_macro ... ) โดยที่สัญลักษณ์และนิพจน์ถูกส่งไปยัง
ฟังก์ชั่นที่ถูกต้อง

=> #^()
;=> (dispatch_reader_macro ^ ())
=> #^"สวัสดี"
"สวัสดี"

คำเตือน:
เนื่องจากข้อจำกัดใน lexer และ parser ของ Hy มาโครตัวอ่านจึงไม่สามารถกำหนดนิยามใหม่ได้
ไวยากรณ์เช่น ()[]{}. สิ่งนี้น่าจะได้รับการแก้ไขในอนาคต

ภายใน Hy เอกสาร
หมายเหตุ:
บิตเหล่านี้ส่วนใหญ่มีประโยชน์สำหรับผู้ที่แฮ็คบน Hy เอง แต่ยังใช้สำหรับ
ผู้ที่เจาะลึกในการเขียนโปรแกรมมาโคร

Hy Models
บทนำ ไปยัง Hy Models
โมเดล Hy เป็นเลเยอร์บาง ๆ ที่ด้านบนของวัตถุ Python ปกติซึ่งเป็นตัวแทนของ Hy source
รหัสเป็นข้อมูล โมเดลเพิ่มข้อมูลตำแหน่งต้นทางเท่านั้น และอีกไม่กี่วิธีในการ
รองรับการจัดการซอร์สโค้ด Hy ที่สะอาดเช่นในมาโคร เพื่อให้บรรลุสิ่งนั้น
เป้าหมาย โมเดล Hy เป็นส่วนผสมของคลาส Python พื้นฐานและ HyObject.

HyObject
hy.models.HyObject เป็นคลาสพื้นฐานของรุ่น Hy มันใช้วิธีเดียวเท่านั้น แทนที่,
ซึ่งจะแทนที่ตำแหน่งต้นทางของวัตถุปัจจุบันด้วยตำแหน่งที่ส่งผ่านเป็นอาร์กิวเมนต์
ทำให้เราสามารถติดตามตำแหน่งเดิมของนิพจน์ที่ได้รับการแก้ไขโดย
มาโครไม่ว่าจะเป็นในคอมไพเลอร์หรือในมาโคร hy ล้วนๆ

HyObject ไม่ได้มีจุดประสงค์เพื่อใช้ในการสร้างแบบจำลอง Hy โดยตรง แต่เป็นส่วนผสมเท่านั้น
สำหรับชั้นเรียนอื่นๆ

สารประกอบ Models
รายการในวงเล็บและในวงเล็บจะถูกแยกวิเคราะห์เป็นแบบจำลองแบบผสมโดยตัวแยกวิเคราะห์ Hy

ไฮลิสต์
hy.models.list.HyList เป็นคลาสพื้นฐานของโมเดล Hy ที่ "ทำซ้ำได้" การใช้งานพื้นฐานคือเพื่อ
เป็นตัวแทนวงเล็บ [] รายการ ซึ่งเมื่อใช้เป็นนิพจน์ระดับบนสุด แปลเป็น
Python แสดงรายการตัวอักษรในขั้นตอนการคอมไพล์

การเพิ่ม HyList ให้กับอ็อบเจกต์ iterable อื่นจะนำคลาสของอ็อบเจกต์ด้านซ้ายมือมาใช้ซ้ำ
ลักษณะการทำงานที่เป็นประโยชน์เมื่อคุณต้องการเชื่อมวัตถุ Hy ในมาโคร เป็นต้น

ไฮ เอ็กเพรสชั่น
hy.models.expression.HyExpression สืบทอด ไฮลิสต์ สำหรับวงเล็บ () นิพจน์ ดิ
ผลลัพธ์การรวบรวมของนิพจน์เหล่านั้นขึ้นอยู่กับองค์ประกอบแรกของรายการ: the
คอมไพเลอร์ส่งนิพจน์ระหว่างคอมไพเลอร์ฟอร์มพิเศษ แมโครที่ผู้ใช้กำหนด และ
การเรียกใช้ฟังก์ชัน Python ปกติ

ไฮดิก
hy.models.dict.ไฮดิก สืบทอด ไฮลิสต์ สำหรับขาหนีบ {} นิพจน์ซึ่งรวบรวม
ลงไปตามตัวอักษรพจนานุกรม Python

การตัดสินใจใช้ list แทน dict เป็น base class for ไฮดิก ช่วยให้ง่ายขึ้น
การจัดการ dicts ในมาโครด้วยข้อดีเพิ่มเติมของการอนุญาตให้ใช้นิพจน์แบบผสม
เป็นคีย์ dict (เช่น the ไฮ เอ็กเพรสชั่น คลาส Python ไม่สามารถแฮชได้)

อะตอม Models
ในสตรีมอินพุต สตริงที่มีเครื่องหมายอัญประกาศคู่ โดยคำนึงถึงสัญกรณ์ Python สำหรับสตริง
ถูกแยกวิเคราะห์เป็นโทเค็นเดียว ซึ่งแยกวิเคราะห์โดยตรงเป็น a ไฮสตริง.

สตริงอักขระต่อเนื่อง ไม่รวมช่องว่าง วงเล็บ เครื่องหมายคำพูด เครื่องหมายคำพูดคู่
และความคิดเห็นจะถูกแยกวิเคราะห์เป็นตัวระบุ

ตัวระบุได้รับการแก้ไขเป็นแบบจำลองอะตอมระหว่างเฟสการแยกวิเคราะห์ในลำดับต่อไปนี้:

· จำนวนเต็ม

· ไฮโฟลต

· ไฮคอมเพล็กซ์ (ถ้าอะตอมไม่เป็นตัวเปล่า j)

· ไฮคีย์เวิร์ด (ถ้าอะตอมขึ้นต้นด้วย :)

· ฮสัญลักษณ์

ไฮสตริง
hy.models.string.HyString เป็นคลาสพื้นฐานของโมเดล Hy ที่เทียบเท่าสตริง นอกจากนี้ยัง
แสดงถึงตัวอักษรสตริงที่มีเครื่องหมายอัญประกาศคู่ ""ซึ่งคอมไพล์ลงไปเป็นสตริงยูนิโค้ด
ตัวอักษรใน Python ไฮสตริงส์ สืบทอดวัตถุ Unicode ใน Python 2 และวัตถุสตริงใน
Python 3 (และไม่ขึ้นกับการเข้ารหัส)

ไฮสตริง โมเดลพื้นฐานจะไม่เปลี่ยนรูป

สตริงตามตัวอักษร Hy สามารถขยายได้หลายบรรทัด และถือว่า parser เป็น single
หน่วย เคารพ Python สำหรับสตริงยูนิโค้ด

เป็นตัวเลข Models
hy.models.integer.HyInteger แสดงถึงตัวอักษรจำนวนเต็ม (โดยใช้ ยาว พิมพ์บน Python 2
และ int บน Python 3)

hy.models.float.ไฮโฟลต แสดงถึงตัวอักษรทศนิยม

hy.models.complex.HyComplex แสดงถึงตัวอักษรที่ซับซ้อน

โมเดลตัวเลขถูกแยกวิเคราะห์โดยใช้รูทีนของ Python ที่สอดคล้องกัน และ python ที่เป็นตัวเลขที่ถูกต้อง
อักษรจะกลายเป็นคู่ Hy ของพวกเขา

ฮสัญลักษณ์
hy.models. symbol.HySymbol เป็นแบบจำลองที่ใช้แทนสัญลักษณ์ในภาษาฮิ มัน
สืบทอด ไฮสตริง.

ฮสัญลักษณ์ ออบเจ็กต์ถูกจัดการในขั้นตอนการแยกวิเคราะห์ เพื่อช่วยให้ Python ทำงานร่วมกันได้:

· สัญลักษณ์ล้อมรอบด้วยดอกจัน (*) จะกลายเป็นตัวพิมพ์ใหญ่

· เส้นประ (-) จะกลายเป็นขีดล่าง (_);

· เครื่องหมายคำถามต่อท้าย (?) กลายเป็นผู้นำ เป็น_.

ข้อแม้: เนื่องจากการทำ mangling เสร็จสิ้นในระหว่างขั้นตอนการแยกวิเคราะห์ เป็นไปได้ที่
สร้าง HySymbols โดยทางโปรแกรมซึ่งไม่สามารถสร้างด้วยซอร์สโค้ดของ Hy อา
กลไกที่ใช้โดย gensym เพื่อสร้างสัญลักษณ์ "uninterned"

ไฮคีย์เวิร์ด
hy.models.keyword.HyKeyword แสดงถึงคีย์เวิร์ดในภาษา Hy คีย์เวิร์ดเป็นสัญลักษณ์ที่ขึ้นต้นด้วย
a :. ชั้นสืบทอด ไฮสตริง.

เพื่อแยกแยะ ไฮคีย์เวิร์ด ราคาเริ่มต้นที่ สัญลักษณ์ HySmbolsโดยไม่มีความเป็นไปได้ของ (โดยไม่สมัครใจ)
การปะทะกัน, อักขระ Unicode แบบใช้ส่วนตัว "\uFDD0" ถูกนำหน้าคำสำคัญ literal
ก่อนการจัดเก็บ

จุดด้อย เซลล์
hy.models.cons.ไฮคอนส์ เป็นตัวแทนของ Python-friendly ข้อเสีย เซลล์. เซลล์ข้อเสียคือ
มีประโยชน์อย่างยิ่งในการเลียนแบบคุณลักษณะของตัวแปร LISP "ปกติ" เช่น Scheme หรือ Common
เสียงกระเพื่อม

เซลล์ข้อเสียคือออบเจ็กต์ 2 รายการที่มี a รถ (หัว) และ a ผบ (หาง). ในบาง Lisp
ตัวแปร เซลล์ข้อเสียเป็นส่วนประกอบพื้นฐาน และนิพจน์ S เป็นจริง
แสดงเป็นรายการเชื่อมโยงของเซลล์ข้อเสีย นี่ไม่ใช่กรณีใน Hy ตามปกติ
นิพจน์ประกอบด้วยรายการ Python ที่ห่อด้วยa ไฮ เอ็กเพรสชั่น. อย่างไรก็ตาม ไฮคอนส์
เลียนแบบพฤติกรรมของเสียงกระเพื่อม "ปกติ" ดังนี้:

· (ข้อเสีย บางสิ่งบางอย่าง ไม่มี) is (ไฮเอ็กซ์เพรสชัน [บางสิ่งบางอย่าง])

· (ข้อเสีย บางสิ่งบางอย่าง บางรายการ) is ((พิมพ์ บางรายการ) (+ [บางสิ่งบางอย่าง] บางรายการ)) (ถ้า
บางรายการ สืบทอดมาจาก รายการ).

· (รับ (ข้อเสีย a b) 0) is a

· (ชิ้น (ข้อเสีย a b) 1) is b

Hy รองรับไวยากรณ์รายการประโดยที่ '(อา . b) วิธี (ข้อเสีย 'a 'ข) และ '(อา b . c) วิธี
(ข้อเสีย 'a (ข้อเสีย 'b 'ค)). หากคอมไพเลอร์พบเซลล์ข้อเสียที่ระดับบนสุด มันจะเพิ่ม
ข้อผิดพลาดในการรวบรวม

ไฮคอนส์ ล้อมอาร์กิวเมนต์ที่ส่งผ่าน (car และ cdr) ในประเภท Hy เพื่อลดการจัดการของ
เซลล์ข้อเสียในบริบทมาโคร

Hy ภายใน ทฤษฎี
ขององค์กร
Hy internals ทำงานโดยทำหน้าที่เป็น front-end ให้กับ Python bytecode ดังนั้น Hy เอง
คอมไพล์ลงใน Python Bytecode อนุญาตให้รันไทม์ Python ที่ไม่ได้แก้ไขเพื่อรันโค้ด Hy
โดยไม่ทันได้สังเกต

วิธีที่เราทำคือการแปล Hy เป็นโครงสร้างข้อมูล Python AST ภายในและ
การสร้าง AST ลงใน Python bytecode โดยใช้โมดูลจากมาตรฐาน Python
ไลบรารี่ เพื่อที่เราจะได้ไม่ต้องทำซ้ำงานทั้งหมดของ Python internals สำหรับทุกๆ
ปล่อย Python เดี่ยว

Hy ทำงานในสี่ขั้นตอน ส่วนต่อไปนี้จะครอบคลุมแต่ละขั้นตอนของ Hy จากต้นทางถึง
รันไทม์

ขั้นตอน 1 และ 2: tokenizing และ วจีวิภาค
ขั้นตอนแรกของการรวบรวม Hy คือการ lex แหล่งที่มาเป็นโทเค็นที่เราสามารถจัดการได้ เรา
ใช้โปรเจ็กต์ที่เรียกว่า rply ซึ่งเป็นตัวแยกวิเคราะห์ที่ดี (และรวดเร็ว) เขียนในชุดย่อย
ของ Python ที่เรียกว่า rpython

รหัส lexing ถูกกำหนดไว้ใน hy.lex.เล็กเซอร์. รหัสนี้ส่วนใหญ่เป็นเพียงการกำหนด Hy
ไวยากรณ์และส่วนที่ยากจริงทั้งหมดได้รับการดูแลโดย rply - เราแค่กำหนด
"โทรกลับ" สำหรับ rply ใน hy.lex.parserซึ่งใช้โทเค็นที่สร้างขึ้นและส่งคืน
รุ่นไฮ.

คุณสามารถคิดว่าโมเดล Hy เป็น "AST" สำหรับ Hy ได้ ซึ่งมาโครทำงานด้วย
(โดยตรง) และมันคือสิ่งที่คอมไพเลอร์ใช้เมื่อคอมไพล์ Hy ลง

SEE เพิ่มเติม:
Section Hy Models สำหรับข้อมูลเพิ่มเติมเกี่ยวกับรุ่น Hy และความหมาย

ขั้นตอน 3: Hy การรวบรวม ไปยัง หลาม AST
นี่คือที่ที่เวทมนตร์ส่วนใหญ่ใน Hy เกิดขึ้น นี่คือที่ที่เรานำ Hy AST (นางแบบ)
และคอมไพล์ลงใน Python AST มีเรื่องขี้ขลาดสองสามอย่างเกิดขึ้นที่นี่เพื่อทำงานที่ผ่านมาไม่กี่ครั้ง
ปัญหาใน AST และการทำงานในคอมไพเลอร์เป็นงานที่สำคัญที่สุดที่เราทำ
มี.

คอมไพเลอร์ค่อนข้างซับซ้อน ดังนั้นอย่ารู้สึกแย่ถ้าคุณไม่ทำมันในช็อตแรก
อาจต้องใช้เวลาสักระยะจึงจะถูกต้อง

จุดเริ่มต้นหลักของคอมไพเลอร์คือ HyASTCompiler.คอมไพล์. วิธีนี้ถูกเรียกใช้และ
วิธีเดียวในคลาส "สาธารณะ" ที่แท้จริง (คือเราไม่ได้สัญญา
API นอกเหนือจากวิธีการนั้น)

ที่จริงแล้ว แม้ภายใน เราไม่ได้เรียกซ้ำโดยตรง แทบไม่เคย เราบังคับเกือบตลอดเวลา
ต้นไม้ Hy ผ่าน รวบรวมและมักจะทำเช่นนี้กับองค์ประกอบย่อยของนิพจน์
ที่เรามี ขึ้นอยู่กับผู้มอบหมายงานตามประเภทที่จะจัดส่งองค์ประกอบย่อยอย่างเหมาะสม

เมธอดทั้งหมดที่พรีฟอร์มการคอมไพล์จะมีเครื่องหมาย @สร้าง() มัณฑนากร คุณสามารถ
ไม่ว่าจะผ่านคลาสของโมเดล Hy ที่คอมไพล์หรือคุณสามารถใช้สตริงสำหรับ
นิพจน์ ฉันจะเคลียร์เรื่องนี้ให้เสร็จในไม่กี่วินาที

ชื่อจริง ระยะ ประเภท-จัดส่ง
มาเริ่มกันที่ รวบรวม กระบวนการ. สิ่งแรกที่เราทำคือตรวจสอบประเภทสิ่งของ
เรากำลังสร้าง เรามองขึ้นไปดูว่าเรามีวิธีการที่สามารถสร้าง ชนิด () ที่เรา
มีและส่งไปยังวิธีการที่สามารถจัดการได้ ถ้าเราไม่มีวิธีใดที่ทำได้
สร้างประเภทนั้นเรายกขึ้นภายใน ข้อยกเว้น.

ตัวอย่างเช่น ถ้าเรามี ไฮสตริงเรามีการแมป Hy AST กับ Python เกือบ 1 ต่อ 1
AST. ดิ คอมไพล์_string วิธีการ ใช้ ไฮสตริงและส่งคืน an ast.Str() นั่นคือ
เติมด้วยหมายเลขบรรทัดและเนื้อหาที่ถูกต้อง

Macro-ขยาย
ถ้าเราได้ ไฮ เอ็กเพรสชั่นเราจะพยายามดูว่านี่คือมาโครที่รู้จักหรือไม่และกดให้มี
มันขยายออกโดยการเรียก hy.มาโคร.มาโครขยายแล้วดันผลลัพธ์กลับเข้าไปใน
HyASTCompiler.คอมไพล์.

ที่สอง ระยะ นิพจน์-จัดส่ง
กรณีพิเศษเพียงอย่างเดียวคือ ไฮ เอ็กเพรสชั่นเนื่องจากเราต้องสร้าง AST ที่แตกต่างกันขึ้นอยู่กับ
ในแบบฟอร์มพิเศษที่เป็นปัญหา เช่น เมื่อเรากดแป้น an (ถ้า จริง จริง เท็จ)เรา
จำเป็นต้องสร้าง ast.ifและคอมไพล์โหนดย่อยอย่างเหมาะสม นี่คือที่ที่ @สร้าง()
ด้วยสตริงที่อาร์กิวเมนต์เข้ามา

สำหรับ คอมไพล์_expression (ซึ่งกำหนดด้วย an @builds (HyExpression)) จะจัดส่ง
ตามสตริงของอาร์กิวเมนต์แรก ถ้าเหตุผลข้อแรกไม่ใช่
สตริง มันจะจัดการกรณีนั้นอย่างถูกต้องเช่นกัน (โดยส่วนใหญ่จะเพิ่ม an ข้อยกเว้น).

หาก Hy ไม่รู้จักสตริง ระบบจะสร้างค่าเริ่มต้นให้ ast.โทรซึ่งจะพยายาม
ทำการโทรแบบรันไทม์ (ใน Python บางอย่างเช่น ฟู()).

ประเด็น ตี กับ หลาม AST
Python AST นั้นยอดเยี่ยม มันทำให้เราเขียนโปรเจ็กต์ที่ทรงพลังเช่นนั้นได้
Python โดยไม่ต้องต่อสู้กับ Python หนักเกินไป เช่นเดียวกับสิ่งใด เรามีส่วนแบ่งที่ยุติธรรมของ
ปัญหาต่างๆ และนี่คือรายการสั้นๆ เกี่ยวกับปัญหาทั่วไปที่คุณอาจพบเจอ

หลาม differentiates ระหว่าง งบ และ การแสดงออก.

นี่อาจไม่ใช่เรื่องใหญ่ - อันที่จริงสำหรับโปรแกรมเมอร์ Python ส่วนใหญ่สิ่งนี้จะ
ไม่นานก็กลายเป็น "ใช่แล้ว"

ใน Python ทำสิ่งที่ชอบ:

พิมพ์ for x in พิสัย(10): ส่ง, เพราะ พิมพ์ พิมพ์นิพจน์และ for ไม่ใช่
นิพจน์ มันเป็นคำสั่งควบคุมโฟลว์ สิ่งที่ชอบ 1 + 1 เป็นนิพจน์ตามที่เป็น แลมบ์ดา
x: 1 + xแต่คุณสมบัติภาษาอื่นๆ เช่น if, for ,หรือ ในขณะที่ เป็นแถลงการณ์

เนื่องจากพวกมันไม่มี "ค่า" กับ Python มันจึงทำให้ Hy ทำงานหนักตั้งแต่ทำบางสิ่ง
กดไลก์ (พิมพ์ (ถ้า จริง จริง เท็จ)) ไม่ใช่เรื่องธรรมดา แต่เป็นที่คาดหวัง

เป็นผลให้เราจัดการสิ่งต่าง ๆ โดยอัตโนมัติโดยใช้ a ผล วัตถุที่เราเสนอใด ๆ ast.stmt
ที่ต้องวิ่งหนีและซิงเกิ้ล ast.expr ที่ใช้หาค่าอะไรก็ได้
ก็แค่วิ่ง Hy ทำสิ่งนี้โดยบังคับให้ทำสิ่งต่างๆ ขณะวิ่ง

ตัวอย่างเช่น Hy:

(พิมพ์ (ถ้าจริงจริงเท็จ))

จะกลายเป็น:

ถ้าเป็นจริง:
_mangled_name_here = จริง
อื่น:
_mangled_name_here = เท็จ

พิมพ์ _mangled_name_here

โอเค นั่นเป็นเรื่องโกหก เพราะเราเปลี่ยนข้อความนั้นเป็น:

พิมพ์ จริง ถ้า จริง อย่างอื่น เท็จ

โดยการบังคับสิ่งต่าง ๆ ให้เป็น ast.expr ถ้าเราทำได้ แต่แนวคิดทั่วไปยังคงมีอยู่

ขั้นตอน 4: หลาม รหัสไบต์ เอาท์พุต และ Runtime
หลังจากที่เรามี Python AST tree ที่เสร็จสมบูรณ์แล้ว เราก็สามารถลองคอมไพล์ไปที่ Python . ได้
bytecode โดยการกดผ่าน ประเมิน. จากนี้ไป เราไม่สามารถควบคุมได้อีกต่อไป และ
Python ดูแลทุกอย่าง นี่คือเหตุผลว่าทำไมสิ่งต่างๆ เช่น Python tracebacks, pdb และ
แอพ django ใช้งานได้

Hy แมโคร
การใช้ เจนซิม for ปลอดภัยมากขึ้น แมโคร
เมื่อเขียนมาโคร ต้องระวังไม่ให้จับตัวแปรภายนอกหรือใช้
ชื่อตัวแปรที่อาจขัดแย้งกับรหัสผู้ใช้

เราจะใช้ตัวอย่างมาโคร n หาก (ดู
http://letoverlambda.com/index.cl/guest/chap3.html#วินาที_5 เพื่อคำอธิบายที่สมบูรณ์ยิ่งขึ้น)
n หาก เป็นตัวอย่าง บางอย่างเช่น ตัวเลข ifโดยที่ขึ้นอยู่กับนิพจน์หนึ่งใน
เรียก 3 รูปแบบขึ้นอยู่กับว่านิพจน์เป็นบวกศูนย์หรือลบ

การผ่านครั้งแรกอาจเป็นดังนี้:

(defmacro นิฟ [expr pos-form zero-form neg-form]
`(ให้ [[ปิดบังชื่อ ~expr]]
(cond [(pos? ปิดบังชื่อ) ~pos-form]
[(ศูนย์? ปิดบังชื่อ) ~รูปแบบศูนย์]
[(neg? ชื่อที่ไม่ชัดเจน) ~ neg-form])))

ที่ไหน หมกมุ่นชื่อ เป็นความพยายามที่จะเลือกชื่อตัวแปรบางอย่างเพื่อไม่ให้ขัดแย้งกับชื่ออื่น
รหัส. แต่แน่นอนว่าถึงแม้จะเจตนาดี แต่ก็ไม่รับประกัน

วิธี gensym ได้รับการออกแบบเพื่อสร้างสัญลักษณ์ใหม่ที่ไม่เหมือนใครสำหรับโอกาสดังกล่าว
รุ่นที่ดีกว่ามากของ n หาก อยากจะเป็น:

(defmacro นิฟ [expr pos-form zero-form neg-form]
(ให้ [[g (gensym)]]
`(ให้ [[~g ~expr]]
(cond [(pos? ~g) ~pos-แบบฟอร์ม]
[(ศูนย์? ~g) ~รูปแบบศูนย์]
[(neg? ~g) ~neg-แบบฟอร์ม]))))

นี่เป็นกรณีที่ง่าย เนื่องจากมีเพียงหนึ่งสัญลักษณ์ แต่ถ้ามีความจำเป็นหลายอย่าง
gensym มีมาโครตัวที่สองที่มี gensym ซึ่งโดยทั่วไปจะขยายเป็นชุดของ ให้
งบ:

(ด้วย-gensyms [abc]
... )

ขยายเป็น:

(ให้ [[a (gensym))
[b (จีซิม)
[ค (เจนซิม)]]
... )

ดังนั้นเราเขียนใหม่ n หาก จะมีลักษณะดังนี้:

(defmacro นิฟ [expr pos-form zero-form neg-form]
(กับ-gensyms [g]
`(ให้ [[~g ~expr]]
(cond [(pos? ~g) ~pos-แบบฟอร์ม]
[(ศูนย์? ~g) ~รูปแบบศูนย์]
[(neg? ~g) ~neg-แบบฟอร์ม]))))

สุดท้ายนี้ แม้ว่าเราจะสามารถสร้างมาโครใหม่ที่ทำหน้าที่ทั้งหมดนี้ให้เราได้ defmacro/g! จะทำ
สัญลักษณ์ทั้งหมดที่ขึ้นต้นด้วย g! และโทรอัตโนมัติ เจนซิม กับส่วนที่เหลือของ
สัญลักษณ์. ดังนั้น ก!ก จะกลายเป็น (เจนซิม "ก").

. เวอร์ชั่นสุดท้ายของเรา n หากสร้างด้วย เดฟมาโคร/g! กลายเป็น:

(defmacro/g! nif [ expr pos-form zero-form neg-form]
`(ให้ [[~g!res ~expr]]
(cond [(pos? ~g!res) ~pos-แบบฟอร์ม]
[(ศูนย์? ~g!res) ~รูปแบบศูนย์]
[(neg? ~g!res) ~neg-แบบฟอร์ม]))))

การตรวจสอบ แมโคร ข้อโต้แย้ง และ การยก ข้อยกเว้น
Hy ผู้รวบรวม บิวท์อิน

Contributor โมดูล ดัชนี

เนื้อหา:

อะนาฟอริก แมโคร
ใหม่ในเวอร์ชัน 0.9.12

โมดูลมาโครแอนาโฟริกทำให้การเขียนโปรแกรมการทำงานใน Hy กระชับและง่ายต่อการ
อ่าน.
แอนาโฟริกมาโครเป็นมาโครการเขียนโปรแกรมประเภทหนึ่งที่จงใจจับรูปแบบบางอย่าง
ให้กับมาโครซึ่งอาจอ้างถึงโดยคำเปรียบเทียบ (นิพจน์ที่อ้างถึง
ไปอีก) — วิกิพีเดีย (http://en.wikipedia.org/wiki/Anaphoric_macro)

แมโคร
ap-ถ้า
การใช้งาน: (ap-ถ้า (ฟู) (พิมพ์ มัน))

ประเมินรูปแรกเพื่อความสัตย์จริง แล้วผูกมัดไว้กับ it ทั้งในความจริงและเท็จ
สาขา

ap-แต่ละ
การใช้งาน: (แอพ-แต่ละ [1 2 3 4 5] (พิมพ์ มัน))

ประเมินแบบฟอร์มสำหรับแต่ละองค์ประกอบในรายการสำหรับผลข้างเคียง

ap-แต่ละขณะ
การใช้งาน: (ap-แต่ละขณะ รายการ เพรด ร่างกาย)

ประเมินแบบฟอร์มสำหรับแต่ละองค์ประกอบที่แบบฟอร์มเพรดิเคตส่งคืน จริง.

=> (ap-each-while [1 2 3 4 5 6] (< it 4) (พิมพ์))
1
2
3

ap-แผนที่
การใช้งาน: (ap-แผนที่ ฟอร์ม รายการ)

รูปแบบแผนที่เชิงเปรียบเทียบทำงานเหมือนกับแผนที่ทั่วไป ยกเว้นว่าแทนที่จะเป็นฟังก์ชัน
วัตถุนั้นอยู่ในรูปแบบ Hy ชื่อพิเศษ it ถูกผูกไว้กับวัตถุปัจจุบันจาก
รายการในการทำซ้ำ

=> (รายการ (ap-map (* มัน 2) [1 2 3]))
[2, 4, 6]

ap-map- when
การใช้งาน: (ap-map- when predfn ตัวแทน รายการ)

ประเมินการแมปเหนือรายการโดยใช้ฟังก์ชันเพรดิเคตเพื่อกำหนดว่าเมื่อใดควรใช้
ฟอร์ม

=> (รายการ (ap-map- เมื่อคี่? (* มัน 2) [1 2 3 4]))
[2, 2, 6, 4]

=> (รายการ (ap-map- เมื่อไหร่? (* มัน 2) [1 2 3 4]))
[1, 4, 3, 8]

ap-กรอง
การใช้งาน: (ap-กรอง ฟอร์ม รายการ)

เช่นเดียวกับ ap-แผนที่ เราใช้รูปแบบพิเศษแทนฟังก์ชันเพื่อกรององค์ประกอบของ
รายการ. ชื่อพิเศษ it ถูกผูกไว้กับองค์ประกอบปัจจุบันในการวนซ้ำ

=> (รายการ (ap-filter (> (* it 2) 6) [1 2 3 4 5]))
[4, 5]

ap-ปฏิเสธ
การใช้งาน: (ap-ปฏิเสธ ฟอร์ม รายการ)

ฟังก์ชันนี้ทำตรงกันข้ามกับ ap-กรอง, มันปฏิเสธองค์ประกอบที่ผ่าน
ภาคแสดง ชื่อพิเศษ it ถูกผูกไว้กับองค์ประกอบปัจจุบันในการวนซ้ำ

=> (รายการ (ap-reject (> (* มัน 2) 6) [1 2 3 4 5]))
[1, 2, 3]

ap-dotimes
การใช้ (ap-dotimes n ร่างกาย)

ฟังก์ชั่นนี้ประเมินร่างกาย n ครั้งด้วยตัวแปรพิเศษ it ผูกพันจาก 0 ไปยัง
1- น. มันมีประโยชน์สำหรับผลข้างเคียง

=> (setv n [])
=> (ap-dotimes 3 (.append n it))
=> น
[0, 1, 2]

แอพแรก
การใช้ (ap-ก่อน predfn รายการ)

ฟังก์ชันนี้ส่งคืนองค์ประกอบแรกที่ผ่านภาคแสดงหรือ ไม่มีด้วย
ตัวแปรพิเศษ it ผูกกับองค์ประกอบปัจจุบันในการวนซ้ำ

=>(ap-first (> it 5) (ช่วง 10))
6

ap-ล่าสุด
การใช้ (ap-สุดท้าย predfn รายการ)

ฟังก์ชันนี้ส่งคืนองค์ประกอบสุดท้ายที่ผ่านเพรดิเคตหรือ ไม่มีด้วยความพิเศษ
ตัวแปร it ผูกกับองค์ประกอบปัจจุบันในการวนซ้ำ

=>(ap-last (> it 5) (range 10))
9

ap-ลด
การใช้ (ap-ลด ฟอร์ม รายการ &ไม่จำเป็น ค่าเริ่มต้น)

ฟังก์ชันนี้ส่งคืนผลลัพธ์ของการใช้แบบฟอร์มกับองค์ประกอบ 2 ตัวแรกในร่างกายและ
ใช้ผลลัพธ์และองค์ประกอบที่ 3 เป็นต้น จนกว่ารายการจะหมด เป็นทางเลือก an
สามารถระบุค่าเริ่มต้นได้ ดังนั้นฟังก์ชันจะถูกนำไปใช้กับค่าเริ่มต้นและ
องค์ประกอบแรกแทน สิ่งนี้เผยให้เห็นองค์ประกอบที่ถูกวนซ้ำเป็น it และปัจจุบัน
มูลค่าสะสมเป็น แม็ก.

=>(ap-reduce (+ ตามมาตรฐาน) (ช่วง 10))
45

วนซ้ำ/ซ้ำ
ใหม่ในเวอร์ชัน 0.10.0

พื้นที่ ห่วง / เกิดขึ้นอีก มาโครช่วยให้โปรแกรมเมอร์มีวิธีง่ายๆ ในการใช้ tail-call Optimization (TCO)
ในรหัส Hy ของพวกเขา
tail call เป็นการเรียกรูทีนย่อยที่เกิดขึ้นภายในโพรซีเดอร์อื่นเป็นขั้นสุดท้าย
หนังบู๊; มันอาจสร้างมูลค่าที่ส่งคืนซึ่งจะถูกส่งกลับทันทีโดยการโทร
ขั้นตอน. หากการเรียกใดๆ ที่รูทีนย่อยดำเนินการ ซึ่งอาจนำไปสู่
ไปยังรูทีนย่อยเดียวกันนี้ที่ถูกเรียกอีกครั้งตามสายการโทร อยู่ในตำแหน่งหาง
รูทีนย่อยดังกล่าวเรียกว่า tail-recursive ซึ่งเป็นกรณีพิเศษของการเรียกซ้ำ
การเรียก Tail มีความสำคัญเนื่องจากสามารถใช้งานได้โดยไม่ต้องเพิ่ม stack . ใหม่
เฟรมไปยังสแต็กการโทร เฟรมส่วนใหญ่ของขั้นตอนปัจจุบันไม่จำเป็นเลย
มากขึ้นและแทนที่ด้วยเฟรมของส่วนท้าย โปรแกรมก็กระโดดได้
ไปยังรูทีนย่อยที่เรียก การสร้างรหัสดังกล่าวแทนลำดับการโทรมาตรฐาน is
เรียกว่า tail call กำจัดหรือ tail call เพิ่มประสิทธิภาพ อนุญาตให้กำจัดการโทรออก
โพรซีเดอร์เรียกในตำแหน่งหางเพื่อดำเนินการอย่างมีประสิทธิภาพเช่นเดียวกับคำสั่ง goto
จึงช่วยให้การเขียนโปรแกรมที่มีโครงสร้างมีประสิทธิภาพ — วิกิพีเดีย (-
http://en.wikipedia.org/wiki/Tail_call)

แมโคร
ห่วง
ห่วง กำหนดจุดเรียกซ้ำ กับ ห่วง, เกิดขึ้นอีก rebinds ตัวแปรที่ตั้งไว้ใน
จุดเรียกซ้ำและส่งการเรียกใช้โค้ดกลับไปที่จุดเรียกซ้ำนั้น ถ้า เกิดขึ้นอีก ถูกใช้ใน
ตำแหน่งที่ไม่ใช่หางมีข้อยกเว้น

การใช้งาน: (ลูป ผูก &พักผ่อน ร่างกาย)

ตัวอย่าง:

(ต้องการ hy.contrib.loop)

(defn แฟกทอเรียล [n]
(วนซ้ำ [[ใน] [acc 1]]
(ถ้า (ศูนย์? ผม)
แม็ก
(เกิดขึ้นอีก (ธันวาคมผม) (* acc i)))))

(แฟคทอเรียล 1000)

defmulti
ใหม่ในเวอร์ชัน 0.10.0

defmulti ให้คุณ arity-overload ฟังก์ชันตามจำนวน args และ/หรือ kwargs ที่กำหนด
แรงบันดาลใจจาก Clojure's take on ป้องกัน.

=> (ต้องการ hy.contrib.multi)
=> (defmulti fun
... ([a] "a")
... ([ab] "ab")
... ([abc] "abc"))
=> (สนุก 1)
"NS"
=> (สนุก 1 2)
"แอ๊บ"
=> (สนุก 1 2 3)
"เอบีซี"

แฮ็ค ON HY

ร่วมเป็นผู้ขายกับเราที่ ของเรา ไฮฟ์!
โปรดมาแฮ็ค Hy!

เชิญร่วมสนุกกับเราได้ที่ #เฮีย on irc.freenode.net!

กรุณาพูดคุยเกี่ยวกับมันบน Twitter กับ #เฮีย แฮชแท็ก!

กรุณาบล็อกเกี่ยวกับมัน!

กรุณาอย่าพ่นสีบนรั้วเพื่อนบ้านของคุณ (โดยไม่ต้องถามดีๆ)!

สับ!
ทำเช่นนี้:

1 สร้าง a เสมือน สิ่งแวดล้อม:

$ virtualenv เวนวี

และเปิดใช้งาน:

$ . venv/bin/เปิดใช้งาน

หรือใช้ virtualenvwrapper เพื่อสร้างและจัดการสภาพแวดล้อมเสมือนของคุณ:

$ mkvirtualenv ไฮ
$ ทำงาน hy

2. รับซอร์สโค้ด:

โคลน $ git https://github.com/hylang/hy.git

หรือใช้ส้อมของคุณ:

$ git โคลน [ป้องกันอีเมล]: /hy.git

3. ติดตั้งสำหรับการแฮ็ค:

$ ซีดี hy/
$ pip ติดตั้ง -e

4. ติดตั้งข้อกำหนดการพัฒนาอื่น ๆ :

$ pip ติดตั้ง -r ข้อกำหนด-dev.txt

5. ทำสิ่งที่ยอดเยี่ยม ทำให้ใครบางคนกรีดร้องด้วยความยินดี / รังเกียจในสิ่งที่คุณได้ทำ

ทดสอบ!
การทดสอบอยู่ใน การทดสอบ /. เราใช้ จมูก.

ในการเรียกใช้การทดสอบ:

$ การทดสอบจมูก

เขียนแบบทดสอบ---แบบทดสอบดีมาก!

นอกจากนี้ ควรทำการทดสอบสำหรับแพลตฟอร์มทั้งหมดที่รองรับและเป็นไปตามข้อกำหนด PEP 8
รหัส. คุณสามารถทำได้โดยเรียกใช้ tox:

$ สารพิษ

เอกสาร!
เอกสารอยู่ใน เอกสาร /. เราใช้ บุคคลลึกลับ.

ในการสร้างเอกสารใน HTML:

$ ซีดีเอกสาร
$ สร้าง html

เขียนเอกสาร---เอกสารดี! แม้แต่เอกสารนี้!

การบริจาค
ยินดีต้อนรับผลงาน & ชื่นชมอย่างมาก ทุกเล็กน้อยช่วยให้ Hy มากขึ้น
น่ากลัว

คำขอดึงนั้นยอดเยี่ยมมาก! เรารักพวกเขา นี่คือคำแนะนำโดยย่อ:

· แยก repo และสร้างสาขาหัวข้อสำหรับคุณลักษณะ/แก้ไข หลีกเลี่ยงการเปลี่ยนแปลงโดยตรง
บนสาขาหลัก

· คุณสมบัติที่เข้ามาทั้งหมดควรมาพร้อมกับการทดสอบ

· ก่อนที่คุณจะส่ง PR โปรดทำการทดสอบและตรวจสอบรหัสของคุณกับสไตล์
แนะนำ. คุณสามารถทำทั้งสองสิ่งนี้พร้อมกันได้:

$ ทำ d

· สร้างคอมมิตเป็นหน่วยตรรกะ เพื่อให้ง่ายต่อการติดตามและนำทางในภายหลัง ก่อน
ส่ง PR ลองบีบคอมมิตเป็นเซ็ตการแก้ไขที่กลับมาได้ง่าย
ภายหลัง. นอกจากนี้ ตรวจสอบให้แน่ใจว่าคุณไม่ได้เว้นช่องว่างปลอมไว้ในเซ็ตการแก้ไข นี้
หลีกเลี่ยงการสร้างการแก้ไขช่องว่างในภายหลัง

· ตราบใดที่มีการส่งข้อความ ให้พยายามปฏิบัติตามสิ่งต่อไปนี้:

· พยายามจำกัดจำนวนอักขระไว้ที่ 50 ตัวสำหรับบรรทัดแรกของข้อความ Git

· หากต้องการทราบรายละเอียด/คำอธิบายเพิ่มเติม โปรดเว้นบรรทัดว่างไว้และดำเนินการต่อ
อธิบายการกระทำโดยละเอียด

· สุดท้าย เพิ่มตัวคุณเองในไฟล์ AUTHORS (เป็นการคอมมิตแยกต่างหาก): คุณสมควรได้รับ :)

· การเปลี่ยนแปลงที่เข้ามาทั้งหมดจะต้องได้รับการสนับสนุนจากสมาชิกหลัก 2 คนในทีมหลักของ Hylang
เห็นได้ชัดว่ายินดีต้อนรับการตรวจสอบเพิ่มเติม แต่เราต้องการอย่างน้อย 2 signoffs สำหรับใดๆ
เปลี่ยนแปลง

· หากสมาชิกหลักกำลังส่งประชาสัมพันธ์ โปรดค้นหาสมาชิกหลัก 2 รายที่ไม่รวม
ผู้ส่งประชาสัมพันธ์ แนวคิดในที่นี้คือเราสามารถทำงานร่วมกับผู้แต่ง PR และคนที่สองได้
ชุดการเปลี่ยนแปลงทั้งหมด

· สำหรับเอกสารประกอบและการเปลี่ยนแปลงเล็กน้อยอื่นๆ เรายินดีรวมหลังจาก ACK หนึ่งรายการ เรามี
ความครอบคลุมต่ำ ดังนั้นจึงเป็นการดีที่จะรักษาแนวกั้นนั้นให้ต่ำ

แกน ทีม
ทีมพัฒนาหลักของ Hy ประกอบด้วยนักพัฒนาต่อไปนี้:

· Julien Danjou

· มอร์เทน ลินเดอรุด

· J เคนเน็ ธ พระมหากษัตริย์

· Gergely เนจี

· ตุกก้า เทอร์โต

· ชาวกะเหรี่ยง รัสทัด

· Abhishek L

· คริส อัลลัน เว็บเบอร์

· คอนราด ฮินเซ็น

· จะ คาห์น-กรีน

· พอล ทาเกลียมอนเต

· นิโคลัส แดนดริมอนต์

· ผมบ๊อบ โทลเบิร์ต

· BERKER เพ็กแซก

· คลินตัน N. ดรายส์บาค

· เขา เซมาจ

ใช้ hy ออนไลน์โดยใช้บริการ onworks.net