hy - Online sa Cloud

PROGRAMA:

NAME

hy - hy Dokumentasyon [larawan: Hy] [larawan]

Sumubok Hy https://try-hy.appspot.com

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

pinagmulan https://github.com/hylang/hy

listahan hylang-usapan

IRC #hy sa Freenode

Magtayo katayuan
Travis CI.UNINDENT

Ang Hy ay isang magandang diyalekto ng Lisp na naka-embed sa Python.

Dahil binago ni Hy ang Lisp code nito sa Python Abstract Syntax Tree, mayroon ka
ang buong magandang mundo ng Python sa iyong mga kamay, sa Lisp form!

Nilalaman:

QUICKSTART

[larawan: Karen Rustard's Cuddles] [larawan]

(Salamat kay Karen Rustad para sa Cuddles!)

PAANO SA GET HY REAL MABILIS:

1. Gumawa ng Totoo Sawa kapaligiran.

2. I-activate ang iyong Virtual Python Environment.

3. Italaga hy mula PyPI sa tuldukan install hy.

4. Magsimula ng REPL gamit ang hy.

5. Mag-type ng mga bagay-bagay sa REPL:

=> (i-print ang "Hy!")
Hy!
=> (defn salutationsnm [pangalan] (print (+ "Hy " pangalan "!")))
=> (salutationsnm "YourName")
Hi YourName!

at iba pa

6. Pindutin ang CTRL-D kapag tapos ka na.

OMG! Iyon ang Kahanga-hangang! I gusto sa magsulat a Hy programa.

7. Magbukas ng elite programming editor at i-type ang:

(i-print ang "Magko-code ako sa Python syntax, ngunit pagkatapos ay nakuha ko si Hy.")

8. I-save bilang awesome.hy.

9. At patakbuhin ang iyong unang Hy program:

hy awesome.hy

10.
Huminga ng malalim para hindi mag-hyperventilate.

11.
Ngumiti ng masama at lumabas sa iyong hydeaway at gumawa ng mga bagay na hindi masabi.

PAGTUTURO

Maligayang pagdating sa Hy tutorial!

Sa madaling sabi, ang Hy ay isang Lisp dialect, ngunit isa na nagko-convert ng istraktura nito sa Python ...
literal na isang conversion sa abstract syntax tree ng Python! (O upang ilagay ito sa mas krudo
mga tuntunin, si Hy ay lisp-stick sa isang Python!)

Ito ay medyo cool dahil nangangahulugan ito na ang Hy ay ilang bagay:

· Isang Lisp na napaka Pythonic

· Para sa Lispers, isang mahusay na paraan upang gamitin ang nakatutuwang kapangyarihan ng Lisp ngunit sa malawak na mundo ng Python
mga aklatan (bakit oo, maaari ka na ngayong magsulat ng isang Django application sa Lisp!)

· Para sa mga Pythonista, isang mahusay na paraan upang simulan ang paggalugad ng Lisp, mula sa ginhawa ng Python!

· Para sa lahat: isang kaaya-ayang wika na mayroong maraming maayos na ideya!

Basic intro sa pagkabulol para Mga Pythonista
Okay, marahil hindi mo pa nagamit ang Lisp, ngunit gumamit ka ng Python!

Ang isang "hello world" na programa sa Hy ay talagang napakasimple. Subukan Natin:

(i-print ang "hello world")

Kita mo? Madali! Tulad ng nahulaan mo, ito ay kapareho ng bersyon ng Python ng:

i-print ang "hello world"

Upang magdagdag ng ilang napakasimpleng matematika, magagawa natin:

(+ 1 3)

Alin ang magbabalik ng 4 at magiging katumbas ng:

1 + 3

Ang mapapansin mo ay ang unang item sa listahan ay ang function na tinatawag at ang
Ang natitirang mga argumento ay ang mga argumentong ipinapasa. Sa katunayan, sa Hy (tulad ng karamihan
Lisps) maaari naming ipasa sa maraming mga argumento sa plus operator:

(+ 1 3 55)

Alin ang magbabalik 59.

Marahil ay narinig mo na ang Lisp dati ngunit hindi mo alam ang tungkol dito. Ang Lisp ay hindi kasing hirap mo
maaaring isipin, at si Hy ay nagmana mula sa Python, kaya ang Hy ay isang mahusay na paraan upang simulan ang pag-aaral ng Lisp.
Ang pangunahing bagay na halata tungkol sa Lisp ay mayroong maraming panaklong. Ito ay maaaring
tila nakakalito sa una, ngunit hindi ito napakahirap. Tingnan natin ang ilang simpleng matematika na
nakabalot sa isang grupo ng mga panaklong na maaari naming ilagay sa Hy interpreter:

(setv result (- (/ (+ 1 3 88) 2) 8))

Magbabalik ito ng 38. Ngunit bakit? Well, maaari naming tingnan ang katumbas na expression sa
sawa:

resulta = ((1 + 3 + 88) / 2) - 8

Kung susubukan mong malaman kung paano gagana ang nasa itaas sa python, siyempre gagawin mo
alamin ang mga resulta sa pamamagitan ng paglutas sa bawat panloob na panaklong. Iyan ang parehong pangunahing ideya sa
Hy. Subukan muna natin ang pagsasanay na ito sa Python:

resulta = ((1 + 3 + 88) / 2) - 8
# pinasimple sa...
resulta = (92/2) - 8
# pinasimple sa...
resulta = 46 - 8
# pinasimple sa...
resulta = 38

Ngayon subukan natin ang parehong bagay sa Hy:

(setv result (- (/ (+ 1 3 88) 2) 8))
; pinasimple sa...
(setv result (- (/ 92 2) 8))
; pinasimple sa...
(setv resulta (- 46 8))
; pinasimple sa...
(setv resulta 38)

Tulad ng malamang na nahulaan mo, ang huling expression na ito ay may setv ibig sabihin ay italaga ang variable
"resulta" sa 38.

Kita mo? Hindi masyadong mahirap!

Ito ang pangunahing premise ng Lisp. Lisp ay nangangahulugang "pagproseso ng listahan"; nangangahulugan ito na ang
ang istraktura ng programa ay talagang mga listahan ng mga listahan. (Kung pamilyar ka sa Python
mga listahan, isipin ang buong istraktura tulad ng nasa itaas ngunit may mga square bracket sa halip, anuman
makikita mo ang istraktura sa itaas bilang isang programa at isang datastructure.) Ito ay
mas madaling maunawaan na may higit pang mga halimbawa, kaya sumulat tayo ng isang simpleng programang Python, subukan ito,
at pagkatapos ay ipakita ang katumbas na programa ng Hy:

def simple_conversation():
print "Hello! Gusto kitang makilala. Sabihin mo sa akin ang tungkol sa iyong sarili!"
name = raw_input("Ano ang pangalan mo?")
edad = raw_input("Ano ang iyong edad?")
print "Hello " + name + "! Nakikita kong ikaw ay " + edad + " taong gulang."

simple_conversation()

Kung patakbuhin natin ang program na ito, maaaring ganito ang:

Kamusta! Gusto kong makilala ka. Sabihin mo sa akin ang tungkol sa iyong sarili!
ano pangalan mo Gary
Ano ang iyong edad? 38
Hello Gary! Nakikita ko na ikaw ay 38 taong gulang.

Ngayon tingnan natin ang katumbas na programa ng Hy:

(defn simpleng-pag-uusap []
(print "Hello! Gusto kitang makilala. Sabihin mo sa akin ang tungkol sa iyong sarili!")
(setv name (raw-input "Ano ang pangalan mo?"))
(setv age (raw-input "Ano ang edad mo?"))
(print (+ "Hello " name "! I see you are "
edad "taon gulang.")))

(simpleng pag-uusap)

Kung titingnan mo ang programa sa itaas, hangga't naaalala mo na ang unang elemento sa bawat isa
listahan ng programa ay ang function (o macro... makukuha natin ang mga mamaya) na tinatawag
at ang natitira ay ang mga argumento, medyo madaling malaman kung ano ang ibig sabihin ng lahat ng ito.
(Sa malamang nahulaan mo rin, defn ay ang Hy na paraan ng pagtukoy ng mga pamamaraan.)

Gayunpaman, maraming tao ang nakakalito sa una dahil napakaraming panaklong,
ngunit maraming bagay na makakatulong na gawing mas madali ito: panatilihing maganda ang indentation at
gumamit ng editor na may tugmang panaklong (tutulungan ka nitong malaman kung ano ang bawat isa
parenthesis pairs up with) at magsisimulang maging komportable ang mga bagay.

Mayroong ilang mga pakinabang sa pagkakaroon ng istraktura ng code na talagang isang napakasimpleng data
istraktura bilang ang core ng Lisp ay batay sa. Sa isang bagay, nangangahulugan ito na ang iyong mga programa ay
madaling i-parse at ang buong aktwal na istraktura ng programa ay napakalinaw na nalantad
sa iyo. (May dagdag na hakbang sa hy kung saan ang istraktura na nakikita mo ay na-convert sa Python's
sariling representasyon ... sa "purer" Lisps tulad ng Common Lisp o Emacs Lisp, ang data
istraktura na nakikita mo sa code at ang istraktura ng data na naisakatuparan ay higit pa
literal na malapit.)

Ang isa pang implikasyon nito ay ang mga macro: kung ang istraktura ng isang programa ay isang simpleng data
istraktura, nangangahulugan iyon na maaari kang magsulat ng code na maaaring magsulat ng code nang napakadali, ibig sabihin, iyon
ang pagpapatupad ng ganap na bagong mga tampok ng wika ay maaaring maging napakabilis. Dati kay Hy, hindi ito
napaka posible para sa mga programmer ng Python ... ngayon ay maaari ka ring gumamit ng hindi kapani-paniwalang mga macro
kapangyarihan (mag-ingat lamang upang hindi nila sila paahon)!

Hy is a Lisp-flavored Sawa
Nag-convert si Hy sa sariling abstract syntax tree ng Python, kaya malapit mo nang makita ang lahat
ang pamilyar na kapangyarihan ng python ay nasa iyong mga kamay.

Mayroon kang ganap na access sa mga uri ng data ng Python at karaniwang library sa Hy. Mag-eksperimento tayo
kasama nito sa hy interpreter:

=> [1 2 3]
[1, 2, 3]
=> {"aso" "kuhol"
... "pusa" "meow"}
...
{'aso': 'bark', 'cat': 'meow'}
=> (, 1 2 3)
(1, 2, 3)

Kung pamilyar ka sa iba pang Lisps, maaaring interesado kang sinusuportahan ng Hy ang Common
Lisp na paraan ng pagsipi:

=> '(1 2 3)
(1L 2L 3L)

Mayroon ka ring access sa lahat ng mga built-in na uri ng magagandang pamamaraan:

=> (.strip " fooooo ")
"fooooo"

Ano ito? Oo nga, ito ay eksaktong kapareho ng:

" fooooo ".strip()

Tama iyan---Lisp na may tuldok na notasyon! Kung mayroon kaming string na ito na itinalaga bilang isang variable, kami
maaari ding gawin ang mga sumusunod:

(setv this-string " fooooo")
(this-string.strip)

Paano ang tungkol sa mga kondisyon?:

(kung (try-some-thing)
(i-print ang "ito ay kung totoo")
(i-print ang "ito ay kung mali"))

Tulad ng masasabi mo sa itaas, ang unang argumento sa if ay isang pagsubok sa katotohanan, ang pangalawang argumento ay
ang katawan kung totoo, at ang ikatlong argumento (opsyonal!) ay kung mali (ibig sabihin. iba).

Kung kailangan mong gumawa ng mas kumplikadong mga kondisyon, makikita mong wala ka elif
available sa Hy. Sa halip, dapat kang gumamit ng tinatawag na kundisyon. Sa Python, maaari mong gawin
isang bagay tulad ng:

somevar = 33
kung somevar > 50:
print "Napakalaki ng variable na iyon!"
elif somevar < 10:
print "Napakaliit ng variable na iyon!"
kung hindi:
print "Ang variable na iyon ay jussssst tama!"

Sa Hy, gagawin mo:

(cond
[(> somevar 50)
(i-print ang "Napakalaki ng variable na iyon!")]
[(< somevar 10)
(i-print ang "Napakaliit ng variable na iyon!")]
[totoo
(i-print ang "Ang variable na iyon ay jussssst tama!")])

Ang mapapansin mo ay iyon kundisyon nag-switch off sa pagitan ng ilang statement na naisakatuparan at
may kondisyong sinuri para sa totoo o kamalian, at pagkatapos ay kaunting code na ipapatupad kung ito ay lumiliko
upang maging totoo. Mapapansin mo rin na ang iba ay ipinatupad sa dulo sa pamamagitan lamang ng
pagsisiyasat para sa totoo -- kasi naman totoo ay palaging magiging totoo, kaya kung aabot tayo sa ganito, gagawin natin
laging tumakbo yan!

Maaari mong mapansin sa itaas na kung mayroon kang code tulad ng:

(kung may kundisyon
(katawan-kung-totoo)
(katawan-kung-mali))

Ngunit sandali! Paano kung gusto mong magsagawa ng higit sa isang pahayag sa katawan ng isa sa
ang mga ito?

Maaari mong gawin ang sumusunod:

(kung (try-some-thing)
(gawin
(i-print ang "ito ay kung totoo")
(i-print ang "at bakit hindi, patuloy nating pag-usapan kung gaano ito katotoo!))
(i-print ang "ito ay mali pa rin"))

Makikita mo na ginamit namin do upang balutin ang maraming pahayag. Kung pamilyar ka sa iba
Lisps, ito ang katumbas ng prog sa ibang lugar.

Nagsisimula ang mga komento sa mga semicolon:

(i-print ang "tatakbo ito")
; (i-print ang "ngunit hindi ito")
(+ 1 2 3); isasagawa namin ang karagdagan, ngunit hindi ang komentong ito!

Ang pag-loop ay hindi mahirap ngunit may isang uri ng espesyal na istraktura. Sa Python, maaari nating gawin:

para ako sa saklaw(10):
i-print ang "'i' ay nasa " + str(i)

Ang katumbas sa Hy ay magiging:

(para sa [i (saklaw 10)]
(print (+ "'i' ay nasa "(str i))))

Maaari ka ring mag-import at gumamit ng iba't ibang mga library ng Python. Halimbawa:

(import os)

(kung (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/anotherdir")
(i-print ang "Hoy, wala doon ang landas na iyon!"))

Mga tagapamahala ng konteksto ng Python (sa mga pahayag) ay ginagamit tulad nito:

(na may [[f (open "/tmp/data.in")]]
(print (.basahin f)))

na katumbas ng:

na may open("/tmp/data.in") bilang f:
print f.read()

At oo, mayroon kaming mga List comprehension! Sa Python maaari mong gawin:

odds_squared = [
pow(num, 2)
para sa num in saklaw(100)
kung bilang % 2 == 1]

Sa Hy, maaari mong gawin ang mga ito tulad ng:

(setv odds-squared
(list-comp
(pow num 2)
(num (range 100))
(= (% bilang 2) 1)))

; At, isang halimbawang walang kahihiyang ninakaw mula sa isang pahina ng Clojure:
; Ilista natin ang lahat ng mga bloke ng isang Chessboard:

(list-comp
(, xy)
(x (saklaw 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')]

May suporta ang Python para sa iba't ibang magarbong argumento at mga argumento ng keyword. Sa Python maaari naming
tingnan ang:

>>> def opsyonal_arg(pos1, pos2, keyword1=Wala, keyword2=42):
... ibalik [pos1, pos2, keyword1, keyword2]
...
>>> opsyonal_arg(1, 2)
[1, 2, Wala, 42]
>>> opsyonal_arg(1, 2, 3, 4)
[1, 2, 3, 4]
>>> opsyonal_arg(keyword1=1, pos2=2, pos1=3, keyword2=4)
[3, 2, 1, 4]

Ang parehong bagay sa Hy:

=> (defn opsyonal-arg [pos1 pos2 &opsyonal na keyword1 [keyword2 42]]
... [pos1 pos2 keyword1 keyword2])
=> (opsyonal-arg 1 2)
[1 2 Wala 42]
=> (opsyonal-arg 1 2 3 4)
[1 2 3 4]

Kung nagpapatakbo ka ng bersyon ng Hy nakalipas na 0.10.1 (hal., git master), mayroon ding magandang bago
keyword argument syntax:

=> (opsyonal-arg :keyword1 1
... :pos2 2
... :pos1 3
... :keyword2 4)
[3, 2, 1, 4]

Kung hindi, maaari mong palaging gamitin mag-aplay. Pero ano mag-aplay?

Pamilyar ka ba sa pagpasa *args at **kwargs sa Python?:

>>> args = [1 2]
>>> kwargs = {"keyword2": 3
... "keyword1": 4}
>>> opsyonal_arg(*args, **kwargs)

Maaari naming kopyahin ito gamit ang mag-aplay:

=> (setv args [1 2])
=> (setv kwargs {"keyword2" 3
... "keyword1" 4})
=> (ilapat ang opsyonal-arg args kwargs)
[1, 2, 4, 3]

Mayroon ding isang istilong diksyunaryo na pagbuo ng mga argumento ng keyword na mukhang:

(defn another-style [&key {"key1" "val1" "key2" "val2"}]
[key1 key2])

Ang pagkakaiba dito ay dahil ito ay isang diksyunaryo, hindi ka maaaring umasa sa anumang partikular
pag-uutos sa mga argumento.

Sinusuportahan din ni Hy *args at **kwargs. Sa Python:

def some_func(foo, bar, *args, **kwargs):
import pprint
pprint.pprint((foo, bar, args, kwargs))

Ang katumbas ng Hy:

(defn some-func [foo bar &rest args &kwargs kwargs]
(import pprint)
(pprint.pprint (, foo bar args kwargs)))

Sa wakas, siyempre kailangan namin ng mga klase! Sa Python, maaari tayong magkaroon ng klase tulad ng:

klase FooBar(object):
"" "
Isa Pang Halimbawang Klase
"" "
def __init__(sarili, x):
sarili.x = x

def get_x(sarili):
"" "
Ibalik ang aming kopya ng x
"" "
ibalik ang sarili.x

Sa Hy:

(defclass FooBar [object]
"Isa pang Halimbawang Klase"
[[--sa loob--
(fn [sarili x]
(setv self.xx)
; Kasalukuyang kailangan para sa --init-- dahil kailangan ng __init__ ng Wala
; Sana mawala na ito :)
Wala)]

[kumuha-x
(fn [sarili]
"Ibalik ang aming kopya ng x"
sarili.x)]])

Maaari mo ring gawin ang mga katangian sa antas ng klase. Sa Python:

Customer ng klase(models.Model):
pangalan = mga modelo.CharField(max_length=255)
address = models.TextField()
mga tala = mga modelo.TextField()

Sa Hy:

(defclass Customer [models.Model]
[[pangalan (models.CharField :max-length 255})]
[address (models.TextField)]
[mga tala (models.TextField)]])

Hy <-> Sawa interop
Sa pamamagitan ng pag-import ng Hy, maaari mong gamitin ang Hy nang direkta mula sa Python!

Kung ise-save mo ang sumusunod sa pagbati.hy:

(defn greet [name] (print "hello from hy," name))

Pagkatapos ay maaari mo itong gamitin nang direkta mula sa python, sa pamamagitan ng pag-import ng hy bago i-import ang module. Sa
Sawa:

import hy
import na pagbati

greetings.greet("Foo")

Maaari ka ring magdeklara ng isang function sa python (o kahit isang klase!) at gamitin ito sa Hy!

Kung ise-save mo ang sumusunod sa greetings.py sa Python:

def greet(pangalan):
print("hello, %s" % (pangalan))

Magagamit mo ito sa Hy:

(pagbati ng import)
(.greet greetings "foo")

Upang gumamit ng mga argumento ng keyword, maaari mong gamitin ang in greetings.py:

def greet(name, title="Sir"):
print("Pagbati, %s %s" % (pamagat, pangalan))

(pagbati ng import)
(.greet greetings "Foo")
(.greet greetings "Foo" "Darth")
(apply (. greetings greet) ["Foo"] {"title" "Lord"})

Alin ang maglalabas ng:

Pagbati, Sir Foo

Pagbati, Darth Foo

Pagbati, Panginoon Foo

Protips!
Itinatampok din ni Hy ang isang bagay na kilala bilang "threading macro", isang talagang maayos na tampok ng
kay Clojure. Ang "threading macro" (isinulat bilang ->) ay ginagamit upang maiwasan ang malalim na pagpupugad ng
mga ekspresyon.

Ipinapasok ng threading macro ang bawat expression sa unang argumento ng susunod na expression
sa halip.

Kunin natin ang klasiko:

(loop (print (eval (basahin)))))

Sa halip na isulat ito nang ganoon, maaari nating isulat ito bilang mga sumusunod:

(-> (basahin) (eval) (print) (loop))

Ngayon, gamit python-sh, maaari naming ipakita kung paano ang threading macro (dahil sa pag-setup ng python-sh)
maaaring gamitin tulad ng isang tubo:

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

Na, siyempre, lumalawak sa:

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

Mas nababasa, hindi ba? Gamitin ang threading macro!

HY Estilo Gabay

“Alam mo, Ministro, hindi ako sumasang-ayon kay Dumbledore sa maraming bagay...ngunit hindi mo maitatanggi na siya ay
may istilo…” — Phineas Nigellus Black, Manloob Manggagawa ng palayok at ang order of ang Piniks

Ang gabay sa istilo ng Hy ay naglalayon na maging isang hanay ng mga pangunahing panuntunan para sa Hyve (oo, ang komunidad ng Hy
Ipinagmamalaki ang sarili sa pagdaragdag ng Hy sa lahat) upang magsulat ng idyomatikong Hy code. Maraming nakukuha si Hy
mula sa Clojure & Common Lisp, habang palaging pinapanatili ang interopability ng Python.

Pagpapakilala
Ang Tao of Hy
Tinanong ni Ummon ang punong monghe, "Anong sutra ang tinuturuan mo?"
"Ang Nirvana Sutra."
"Ang Nirvana Sutra ay may Apat na Virtues, hindi ba?"
"Meron na."
Tanong ni Ummon, na pinulot ang isang tasa, "Ilan ang mga birtud nito?"
"Wala naman," sabi ng monghe.
"Ngunit sinabi ng mga sinaunang tao na mayroon ito, hindi ba?" sabi ni Ummon.
"Ano sa tingin mo ang sinabi nila?"
Hinampas ni Ummon ang tasa at nagtanong, "Naiintindihan mo?"
"Hindi," sabi ng monghe.
"Kung gayon," sabi ni Ummon, "Mas mabuting ituloy mo ang iyong mga lektura sa sutra."
— ang (koan) macro

Ang mga sumusunod ay naglalarawan ng isang maikling listahan ng mga desisyon sa disenyo na napunta sa paggawa ng
Hy.

· Magmukhang Lisp; DTRT kasama nito (hal. ang mga gitling ay nagiging underscore, ang mga earmuff ay nagiging
all-caps).

· Python pa rin kami. Karamihan sa mga internal ay nagsasalin ng 1:1 sa Python internals.

· Gamitin ang Unicode sa lahat ng dako.

· Ayusin ang masasamang desisyon sa Python 2 kapag kaya natin (tingnan true_division).

· Kapag may pagdududa, ipagpaliban ang Python.

· Kung hindi ka pa rin sigurado, ipagpaliban sa Clojure.

· Kung mas hindi ka sigurado, ipagpaliban ang Common Lisp.

· Tandaan na hindi kami Clojure. Hindi kami Common Lisp. Kami ay Homoiconic Python, kasama
mga dagdag na piraso na may katuturan.

Kaayusan & Indentation
· Iwasan ang mga trailing space. Nakakahiya sila!

· Ang indentation ay dapat na 2 space (walang hard tab), maliban kapag tumutugma sa indentation ng
ang naunang linya.

;; Mabuti (at mas gusto)
(defn fib [n]
(kung (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Okay pa rin
(defn fib [n]
(kung (<= n 2) n (+ (fib (- n 1)) (fib (- n 2)))))

;; Okay pa rin
(defn fib [n]
(kung (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Hysterically katawa-tawa
(defn fib [n]
(kung (<= n 2)
n ;; oo, gusto kong random na pindutin ang space key
(+ (fib (- n 1)) (fib (- n 2)))))

· Ang mga panaklong ay dapat hindi kailanman maiwang mag-isa, malungkot at malungkot sa sarili nilang linya.

;; Mabuti (at mas gusto)
(defn fib [n]
(kung (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Hysterically katawa-tawa
(defn fib [n]
(kung (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))
)
); GAH, SUNOG MO SA APOY

· Patayong ihanay pabayaan Mga bloke.

(hayaan [[foo (bar)]]
[qux (baz)]]
(foo qux))

· Ang mga inline na komento ay dapat dalawang puwang mula sa dulo ng code; dapat lagi silang may a
puwang sa pagitan ng karakter ng komento at simula ng komento. Gayundin, subukang huwag
comment ang obvious.

;; Mabuti
(setv ind (dec x)); Ang pag-index ay nagsisimula sa 0

;; Style-compliant pero sinasabi lang ang obvious
(setv ind (dec x)); nagtatakda ng index sa x-1

;; Masama
(setv ind (dec x));pag-type ng mga salita para masaya

coding estilo
· Bilang isang kombensiyon, subukang huwag gamitin def para sa anumang bagay maliban sa mga pandaigdigang variable; gamitin setv
mga function sa loob, mga loop, atbp.

;; Mabuti (at mas gusto)
(def *limit* 400000)

(defn fibs [ab]
(habang totoo
(nagbubunga ng a)
(setv (, ab) (, b (+ ab)))))

;; Masama (at hindi ginusto)
(defn fibs [ab]
(habang totoo
(nagbubunga ng a)
(def (, ab) (, b (+ ab)))))

· Huwag gumamit ng s-expression syntax kung saan nilayon ang vector syntax. Halimbawa, ang katotohanan
na ang dating ng dalawang halimbawang ito ay gumagana dahil lang sa compiler ay hindi sobra
mahigpit. Sa katotohanan, ang tamang syntax sa mga lugar na tulad nito ay ang huli.

;; Masama (at masama)
(defn foo (x) (print x))
(foo 1)

;; Mabuti (at mas gusto)
(defn foo [x] (print x))
(foo 1)

· Gamitin ang threading macro o ang threading tail macros kapag nakatagpo ng malalim na nested
mga s-expression. Gayunpaman, maging matalino kapag ginagamit ang mga ito. Gamitin ang mga ito kapag malinaw at
nagpapabuti ang pagiging madaling mabasa; huwag bumuo ng convoluted, mahirap maunawaan expression.

;; Mas gusto
(def *pangalan*
(na may [f (bukas na "name.txt")]
(-> (.read f) (.strip) (.replace "\"" "") (.split ","") (sorted))))

;; Hindi mabuti
(def *pangalan*
(na may [f (bukas na "name.txt")]
(pinagbukud-bukod (.split "," (.palitan ang "\"" "" (.strip (.read f)))))))

;; Malamang hindi magandang ideya
(defn square? [x]
(->> 2 (pow (int (sqrt x))) (= x)))

· Mas gusto ang Clojure-style na dot notation kaysa sa direktang tawag ng method ng object,
kahit na pareho ay patuloy na susuportahan.

;; Mabuti
(na may [fd (bukas "/ etc / passwd")]
(print (.readlines fd)))

;; Hindi mabuti
(na may [fd (bukas "/ etc / passwd")]
(print (fd.readlines)))

Konklusyon
"Ang mga fashion ay kumukupas, ang istilo ay walang hanggan" -Yves Saint Laurent

Ang patnubay na ito ay isang hanay lamang ng mga alituntunin ng komunidad, at malinaw naman, ginagawa ng mga alituntunin ng komunidad
walang saysay kung walang aktibong komunidad. Malugod na tinatanggap ang mga kontribusyon. Samahan kami sa #hy in
freenode, mag-blog tungkol dito, mag-tweet tungkol dito, at higit sa lahat, magsaya kasama si Hy.

salamat
· Ang gabay na ito ay lubos na inspirasyon mula sa @paultag blog post ni Hy Kaligtasan ng buhay patnubayan

· Ang Clojure estilo patnubayan

Dokumentasyon INDEX

Nilalaman:

Utos Linya interface
hy
Utos Linya Options
-c
Ipatupad ang Hy code sa utos.

$ hy -c "(print (+ 2 2))"
4

-i
Ipatupad ang Hy code sa utos, pagkatapos ay manatili sa REPL.

-m
Ipatupad ang Hy code sa module, Kabilang ang defmain kung tinukoy.

Ang -m Tinatapos ng flag ang listahan ng mga opsyon upang ang lahat ng mga argumento pagkatapos ng module pangalan
ay ipinapasa sa module sa sys.argv.

Bago sa bersyon 0.10.2.

--espiya Mag-print ng katumbas na Python code bago i-execute. Halimbawa:

=> (defn salutationsnm [pangalan] (print (+ "Hy " pangalan "!")))
def salutationsnm(pangalan):
return print(((u'Hy ' + name) + u'!'))
=> (salutationsnm "YourName")
salutationsnm(u'YourName')
Hi YourName!
=>

Bago sa bersyon 0.9.11.

--show-tracebacks
Mag-print ng mga pinahabang traceback para sa mga pagbubukod sa Hy.

Bago sa bersyon 0.9.12.

-v I-print ang numero ng bersyon ng Hy at lumabas.

hyc
Utos Linya Options
file[, fileN]
I-compile ang Hy code sa Python bytecode. Halimbawa, i-save ang sumusunod na code bilang
hyname.hy:

(defn hy-hy [pangalan]
(print (+ "Hy " name "!")))

(hy-hy "Afroman")

Pagkatapos ay tumakbo:

$ hyc hyname.hy
$ python hyname.pyc
Hy Afroman!

hy2py
Bago sa bersyon 0.10.1.

Utos Linya Options
-s

--may-pinagmulan
Ipakita ang na-parse na istraktura ng pinagmulan.

-a

--kasama-ast
Ipakita ang nabuong AST.

-np

--walang-python
Huwag ipakita ang Python code na nabuo mula sa AST.

Hy (Ang wika)
BABALA:
Ito ay hindi kumpleto; mangyaring isaalang-alang ang pagbibigay ng kontribusyon sa pagsusumikap sa dokumentasyon.

Teorya of Hy
Pinapanatili ni Hy, higit sa lahat, ang 100% compatibility sa parehong direksyon gamit ang Python
mismo. Ang lahat ng Hy code ay sumusunod sa ilang simpleng panuntunan. Isaulo ito, dahil ito ay papasok
madaling-gamiting.

Nakakatulong ang mga panuntunang ito na matiyak na ang Hy code ay idiomatic at interfaceable sa parehong wika.

· Ang mga simbolo sa earmuf ay isasalin sa upper-case na bersyon ng string na iyon. Para sa
Halimbawa, foo ay magiging FOO.

· Ang mga entity ng UTF-8 ay ie-encode gamit punnycode at may unlaping hy_. Halimbawa, ⚘
ay magiging hy_w7h, ♥ ay magiging hy_g6h, at ako♥u ay magiging hy_iu_t0x.

· Ang mga simbolo na naglalaman ng mga gitling ay papalitan ang mga ito ng mga salungguhit. Halimbawa,
render-template ay magiging render_template. Nangangahulugan ito na ang mga simbolo na may mga gitling ay gagawin
anino ang kanilang mga katumbas na salungguhit, at kabaliktaran.

Mga Built-In
Nagtatampok ang Hy ng ilang espesyal na form na ginagamit upang makatulong na bumuo ng tamang Python AST.
Ang mga sumusunod ay "espesyal" na mga form, na maaaring may gawi na medyo hindi inaasahan
ilang sitwasyon.

.
Bago sa bersyon 0.10.0.

. ay ginagamit upang magsagawa ng access sa katangian sa mga bagay. Gumagamit ito ng maliit na DSL upang payagan ang mabilis
access sa mga attribute at item sa isang nested data structure.

Halimbawa,

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

Kino-compile hanggang sa:

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

. pinagsama-sama ang unang argumento nito (sa halimbawa, foo) bilang bagay kung saan gagawin ang
hindi pagtukoy sa katangian. Gumagamit ito ng mga hubad na simbolo bilang mga katangian upang ma-access (sa halimbawa, bar,
base, frob), at pinagsama-sama ang mga nilalaman ng mga listahan (sa halimbawa, [(+ 1 2)]) para sa indexation.
Ang iba pang mga argumento ay nagtatapon ng error sa compilation.

Ang pag-access sa hindi kilalang mga katangian ay nagtatapon ng isang AttributeError. Ang pag-access sa hindi kilalang mga susi ay nagtatapon ng isang
IndexError (sa mga listahan at tuple) o a KeyError (sa mga diksyunaryo).

->
-> (O ang sinulid macro) ay ginagamit upang maiwasan ang nesting ng mga expression. Ang threading macro
ipinapasok ang bawat expression sa unang lugar ng argumento ng susunod na expression. Ang mga sumusunod
ipinapakita ito ng code:

=> (defn output [ab] (print ab))
=> (-> (+ 4 6) (output 5))
10 5

- >>
- >> (O ang sinulid buntot macro) ay katulad ng sinulid macro, ngunit sa halip na
pagpasok ng bawat expression sa unang argumento ng susunod na expression, idinadagdag ito bilang ang
huling argumento. Ang sumusunod na code ay nagpapakita nito:

=> (defn output [ab] (print ab))
=> (->> (+ 4 6) (output 5))
5 10

mag-aplay
mag-aplay ay ginagamit upang maglapat ng opsyonal na listahan ng mga argumento at opsyonal na diksyunaryo ng kwarg
sa isang function.

Paggamit ng: (mag-apply fn-pangalan [args] [kwargs])

Halimbawa:

(defn think []
"hi there")

(ilapat ang thunk)
; => "hi there"

(defn total-purchase [halaga ng presyo at opsyonal [mga bayarin 1.05] [vat 1.1]]
(* halaga ng presyo bayad sa vat))

(ilapat ang kabuuang pagbili [10 15])
;=> 173.25

(ilapat ang kabuuang pagbili [10 15] {"vat" 1.05})
;=> 165.375

(ilapat ang kabuuang pagbili [] {"price" 10 "amount" 15 "vat" 1.05})
;=> 165.375

at
at ay ginagamit sa mga lohikal na pagpapahayag. Ito ay tumatagal ng hindi bababa sa dalawang mga parameter. Kung ang lahat ng mga parameter
suriin sa Totoo, ibinalik ang huling parameter. Sa anumang iba pang kaso, ang unang maling halaga
ibabalik. Halimbawa ng paggamit:

=> (at True False)
Huwad

=> (at True True)
Totoo

=> (at Tama 1)
1

=> (at Tama [] Mali Tama)
[]

TANDAAN:
at short-circuits at huminto sa pagsusuri ng mga parameter sa sandaling ang unang false ay
nakatagpo.

=> (at Mali (i-print ang "hello"))
Huwad

igiit
igiit ay ginagamit upang i-verify ang mga kundisyon habang tumatakbo ang program. Kung ang kundisyon ay hindi
nakilala, an AssertionError ay naitaas. igiit maaaring tumagal ng isa o dalawang parameter. Ang una
parameter ay ang kundisyon upang suriin, at dapat itong suriin sa alinman Totoo or Huwad. ang
ang pangalawang parameter, opsyonal, ay isang label para sa assert, at ang string na magiging
itinaas kasama ang AssertionError. Halimbawa:

(igiit (= variable na inaasahang-halaga))

(igiit na Mali)
; AssertionError

(igiit (= 1 2) "dapat ang isa ay katumbas ng dalawa")
; AssertionError: ang isa ay dapat katumbas ng dalawa

asoc
asoc ay ginagamit upang iugnay ang isang susi sa isang halaga sa isang diksyunaryo o upang magtakda ng isang index ng isang listahan
sa isang halaga. Ito ay tumatagal ng hindi bababa sa tatlong mga parameter: ang data kaayusan upang baguhin, a susi
or index, At isang halaga. Kung higit sa tatlong mga parameter ang gagamitin, ito ay mag-uugnay sa mga pares.

Mga halimbawa ng paggamit:

=>(hayaan [[koleksiyon {}]]
... (assoc collection "Dog" "Bark")
... (koleksiyon ng print))
{u'Dog': u'Bark'}

=>(hayaan [[koleksiyon {}]]
... (assoc collection "Aso" "Bark" "Cat" "Meow")
... (koleksiyon ng print))
{u'Cat': u'Meow', u'Dog': u'Bark'}

=>(hayaan [[koleksiyon [1 2 3 4]]]
... (assoc collection 2 Wala)
... (koleksiyon ng print))
[1, 2, Wala, 4]

TANDAAN:
asoc binabago ang datastructure sa lugar at nagbabalik Wala.

masira
masira ay ginagamit upang lumabas mula sa isang loop. Tinatapos nito kaagad ang loop. Ang mga sumusunod
ang halimbawa ay may walang hanggan habang loop na wawakasan sa sandaling pumasok ang user k.

(habang Tama (kung (= "k" (raw-input "? "))
(pahinga)
(i-print ang "Subukan muli")))

kundisyon
kundisyon maaaring gamitin sa pagbuo ng nested if mga pahayag. Ang sumusunod na halimbawa ay nagpapakita ng
ugnayan sa pagitan ng macro at pagpapalawak nito:

(kondisyon [kondisyon-1 resulta-1]
[kondisyon-2 resulta-2])

(kung kondisyon-1 resulta-1
(kung kondisyon-2 resulta-2))

Gaya ng ipinapakita sa ibaba, tanging ang unang bloke ng resulta ng pagtutugma ang naisasagawa.

=> (defn check-value [value]
... (cond [(< value 5) (i-print ang "value is smaller than 5")]
... [(= halaga 5) (i-print ang "halaga ay katumbas ng 5")]
... [(> value 5) (i-print ang "value is greater than 5")]
... [Totoo (i-print ang "halaga ay isang bagay na hindi dapat")]))

=> (check-value 6)
ang halaga ay higit sa 5

magpatuloy
magpatuloy nagbabalik ng execution sa simula ng isang loop. Sa sumusunod na halimbawa,
(side-effect1) ay tinatawag para sa bawat pag-ulit. (side-effect2), gayunpaman, ay tinatawag lamang
bawat iba pang halaga sa listahan.

;; ipagpalagay na ang (side-effect1) at (side-effect2) ay mga function at
;; Ang koleksyon ay isang listahan ng mga numerong halaga

(para sa [x collection]
(gawin
(side-effect1 x)
(kung (% x 2)
(magpatuloy))
(side-effect2 x)))

dict-comp
dict-comp ay ginagamit sa paglikha ng mga diksyunaryo. Ito ay tumatagal ng tatlo o apat na mga parameter. Ang una
dalawang parameter ay para sa pagkontrol sa return value (key-value pair) habang ang pangatlo ay
ginagamit upang pumili ng mga item mula sa isang sequence. Maaaring gamitin ang ikaapat at opsyonal na parameter
salain ang ilan sa mga item sa sequence batay sa isang conditional expression.

=> (dict-comp x (* x 2) [x (range 10)] (kakaiba? x))
{1: 2, 3: 6, 9: 18, 5: 10, 7: 14}

do / prog
do at prog ay ginagamit upang suriin ang bawat isa sa kanilang mga argumento at ibalik ang huli. Bumalik
ang mga halaga mula sa bawat iba kaysa sa huling argumento ay itatapon. Maaari itong magamit sa lambda or
listahan-comp upang magsagawa ng mas kumplikadong lohika tulad ng ipinapakita sa isa sa mga sumusunod na halimbawa.

Ilang halimbawa ng paggamit:

=> (kung totoo
... (gawin (i-print ang "Side effects rock!")
... (i-print ang "Oo, talaga!")))
Mga side effect rock!
Oo, talaga!

;; ipagpalagay na ang (side-effect) ay isang function na gusto naming tawagan para sa bawat isa
;; at bawat halaga sa listahan, ngunit kung kaninong halaga ang ibinabalik ay hindi namin pinapahalagahan
=> (list-comp (gawin (side-effect x))
... (kung (< x 5) (* 2 x)
... (* 4 x)))
... (x (saklaw 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do maaaring tumanggap ng anumang bilang ng mga argumento, mula 1 hanggang n.

def / setv
def at setv ay ginagamit upang itali ang isang halaga, bagay, o function sa isang simbolo. Halimbawa:

=> (def names ["Alice" "Bob" "Charlie"])
=> (i-print ang mga pangalan)
[u'Alice', u'Bob', u'Charlie']

=> (setv counter (fn [collection item] (.count collection item)))
=> (counter [1 2 3 4 5 2 3] 2)
2

defclass
Ang mga bagong klase ay idineklara na may defclass. Maaaring tumagal ng dalawang opsyonal na parameter: isang vector
pagtukoy ng posibleng mga super class at isa pang vector na naglalaman ng mga katangian ng bago
klase bilang dalawang item vector.

(defclass class-name [super-class-1 super-class-2]
[[attribute value]])

Ang parehong mga halaga at function ay maaaring itali sa bagong klase tulad ng ipinapakita ng halimbawa sa ibaba:

=> (defclass Cat []
... [[edad Wala]
... [kulay "puti"]
... [magsalita (fn [sarili] (i-print ang "Meow"))]])

=> (def spot (Cat))
=> (setv spot.colour "Black")
'Itim'
=> (.speak spot)
meow

defn / defun
defn at defun Ang mga macro ay ginagamit upang tukuyin ang mga function. Kumuha sila ng tatlong parameter: ang pangalan
ng function upang tukuyin, isang vector ng parameter, at ang katawan ng function:

(defn name [params] body)

Maaaring may mga sumusunod na keyword ang mga parameter sa harap nila:

&opsyonal
Opsyonal ang parameter. Ang parameter ay maaaring ibigay bilang isang listahan ng dalawang item, kung saan ang
ang unang elemento ay ang pangalan ng parameter at ang pangalawa ay ang default na halaga. Ang parameter
ay maaari ding ibigay bilang isang item, kung saan ang default na halaga ay Wala.

=> (defn total-value [value &opsyonal [value-added-tax 10]]
... (+ (/ (* value value-added-tax) 100) value))

=> (kabuuang halaga 100)
110.0

=> (kabuuang halaga 100 1)
101.0

&susi

&kwargs
Maglalaman ang parameter ng 0 o higit pang mga argumento ng keyword.

Ang sumusunod na mga halimbawa ng code ay tumutukoy sa isang function na magpi-print ng lahat ng keyword
mga argumento at ang kanilang mga halaga.

=> (defn print-parameters [&kwargs kwargs]
... (para sa [(, kv) (.item kwargs)] (print kv)))

=> (ilapat ang mga print-parameter [] {"parameter-1" 1 "parameter-2" 2})
parameter-2 2
parameter-1 1

&magpahinga Maglalaman ang parameter ng 0 o higit pang positional na argumento. Walang ibang positional
maaaring tukuyin ang mga argumento pagkatapos nito.

Ang sumusunod na halimbawa ng code ay tumutukoy sa isang function na maaaring bigyan ng 0 hanggang n numerical
mga parameter. Binubuo nito ang bawat kakaibang numero at ibinabawas ang bawat even na numero.

=> (defn zig-zag-sum [&rest number]
(hayaan [[odd-numbers (list-comp x [x numbers]) (odd? x))]
[even-numbers (list-comp x [x numbers] (even? x))]]
(- (sum odd-numbers) (sum even-numbers))))

=> (zig-zag-sum)
0
=> (zig-zag-sum 3 9 4)
8
=> (zig-zag-sum 1 2 3 4 5 6)
-3

defn-alias / defun-alias
Bago sa bersyon 0.10.0.

Ang defn-alias at defun-alias ang mga macro ay katulad defn, na may pagkakaiba na
sa halip na tukuyin ang isang function na may iisang pangalan, maaari din itong tukuyin ang mga alias. Iba pa
kaysa sa pagkuha ng isang listahan ng mga simbolo para sa mga pangalan ng function bilang unang parameter, defn-alias at
defun-alias ay walang pinagkaiba sa defn at defun.

=> (defn-alias [pangunahing pangalan alias] []
... (i-print ang "Hello!"))
=> (pangunahing pangalan)
"Kamusta!"
=> (alias)
"Kamusta!"

defmain
Bago sa bersyon 0.10.1.

Ang defmain Tinutukoy ng macro ang isang pangunahing function na agad na tinatawag na may sys.argv as
mga argumento kung at kung ang file na ito ay isinasagawa bilang isang script. Sa madaling salita, ito:

(defmain [&rest args]
(gumawa-isang bagay-na may args))

ay katumbas ng:

def main(*args):
do_something_with(args)
bumalik 0

kung __pangalan__ == "__pangunahing__":
import sys
retval = main(*sys.arg)

kung isinstance(retval, int):
sys.exit(retval)

Tandaan na tulad ng nakikita mo sa itaas, kung magbabalik ka ng integer mula sa function na ito, ito ay magiging
ginamit bilang exit status para sa iyong script. (Default ng Python na lumabas sa status 0 kung hindi,
ibig sabihin okay na ang lahat!)

(Dahil (sys.exit 0) ay hindi tahasang tumatakbo sa kaso ng isang non-integer return mula sa
defmain, magandang ideya na ilagay (defmain) bilang huling piraso ng code sa iyong file.)

defmacro
defmacro ay ginagamit upang tukuyin ang mga macro. Ang pangkalahatang format ay (defmacro pangalan [mga parameter]
expr).

Ang sumusunod na halimbawa ay tumutukoy sa isang macro na maaaring magamit upang magpalit ng pagkakasunud-sunod ng mga elemento sa code,
na nagpapahintulot sa user na magsulat ng code sa infix notation, kung saan ang operator ay nasa pagitan ng
operand.

=> (defmacro infix [code]
... (quasiquote (
... (i-unquote (kumuha ng code 1))
... (i-unquote (kumuha ng code 0))
... (i-unquote (kunin ang code 2)))))

=> (infix (1 + 1))
2

defmacro-alias
defmacro-alias ay ginagamit upang tukuyin ang mga macro na may maraming pangalan (mga alias). Ang pangkalahatang format
is (defmacro-alias [mga pangalan] [mga parameter] expr). Lumilikha ito ng maraming macro na may pareho
listahan ng parameter at katawan, sa ilalim ng tinukoy na listahan ng mga pangalan.

Ang sumusunod na halimbawa ay tumutukoy sa dalawang macro, na parehong nagpapahintulot sa user na magsulat ng code
infix notation.

=> (defmacro-alias [infix infi] [code]
... (quasiquote (
... (i-unquote (kumuha ng code 1))
... (i-unquote (kumuha ng code 0))
... (i-unquote (kunin ang code 2)))))

=> (infix (1 + 1))
2
=> (infi (1 + 1))
2

defmacro/g!
Bago sa bersyon 0.9.12.

defmacro/g! ay isang espesyal na bersyon ng defmacro na ginagamit upang awtomatikong makabuo gensym
para sa anumang simbolo na nagsisimula sa g!.

Halimbawa, ga magiging (gensym "a").

TINGNAN DIN:
Seksyon gamit ang-gensym

defreader
Bago sa bersyon 0.9.12.

defreader ay tumutukoy sa isang macro ng mambabasa, na nagbibigay-daan sa iyong muling ayusin o baguhin ang syntax.

=> (defreader ^ [expr] (print expr))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Kumusta"
"Kamusta"

TINGNAN DIN:
Mga Macro ng Mambabasa ng Seksyon

del
Bago sa bersyon 0.9.12.

del nag-aalis ng isang bagay mula sa kasalukuyang namespace.

=> (setv foo 42)
=> (del foo)
=> foo
Traceback (pinakahuling huling tawag):
file " ", linya 1, sa
NameError: hindi tinukoy ang pangalang 'foo'

del maaari ring mag-alis ng mga bagay mula sa mga pagmamapa, listahan, at higit pa.

=> (setv test (listahan (saklaw 10)))
=> pagsubok
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (del (slice test 2 4)) ;; alisin ang mga item mula 2 hanggang 4 na hindi kasama
=> pagsubok
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "bar"})
=> dic
{"foo": "bar"}
=> (del (kumuha ng dic "foo"))
=> dic
{}

likas na matalino
Bago sa bersyon 0.10.1.

likas na matalino ay ginagamit upang pasimplehin ang isang pagkakasunud-sunod ng mga tawag sa pamamaraan sa isang bagay.

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

=> (setv collection [])
=> (.idagdag ang koleksyon 1)
=> (.idagdag ang koleksyon 2)
=> (.reverse collection)
=> koleksyon
[2 1]

eval
eval sinusuri ang isang naka-quote na expression at ibinabalik ang halaga.

=> (eval '(print "Hello World"))
"Hello World"

eval-and-compile
eval-kapag-compile
una / kotse
una at kotse ay mga macro para sa pag-access sa unang elemento ng isang koleksyon:

=> (una (saklaw 10))
0

para
para ay ginagamit upang tumawag ng isang function para sa bawat elemento sa isang listahan o vector. Ang mga resulta ng bawat isa
ang tawag ay itinapon at ang para bumabalik ang ekspresyon Wala sa halip. Ang halimbawang code ay umuulit
sa ibabaw koleksyon at para sa bawat isa sangkap in koleksyon tawag sa side effect gumana sa
sangkap bilang argumento nito:

;; ipagpalagay na ang (side-effect) ay isang function na kumukuha ng isang parameter
(para sa [element collection] (side-effect element))

;; para sa maaaring magkaroon ng opsyonal else block
(para sa [element collection] (side-effect element)
(iba pa (side-effect-2)))

Ang opsyonal iba Ang block ay isinasagawa lamang kung ang para normal na nagtatapos ang loop. Kung ang
ang pagpapatupad ay itinigil sa masira, ang iba hindi execute ang block.

=> (para sa [elemento [1 2 3]] (kung (< elemento 3)
... (print element)
... (pahinga))
... (iba pa (i-print ang "loop tapos")))
1
2

=> (para sa [elemento [1 2 3]] (kung (< elemento 4)
... (print element)
... (pahinga))
... (iba pa (i-print ang "loop tapos")))
1
2
3
natapos ang loop

genexpr
genexpr ay ginagamit upang lumikha ng mga expression ng generator. Ito ay tumatagal ng dalawa o tatlong mga parameter. Ang
ang unang parameter ay ang expression na kumokontrol sa return value, habang ginagamit ang pangalawa
upang pumili ng mga item mula sa isang listahan. Ang pangatlo at opsyonal na parameter ay maaaring gamitin upang i-filter out
ilan sa mga item sa listahan batay sa isang conditional expression. genexpr ay katulad ng
listahan-comp, maliban kung nagbabalik ito ng isang iterable na nagsusuri ng mga halaga nang paisa-isa sa halip na
agad na sinusuri ang mga ito.

=> (def collection (saklaw 10))
=> (def na-filter (genexr x [x collection] (kahit? x)))
=> (na-filter ang listahan)
[0, 2, 4, 6, 8]

gensym
Bago sa bersyon 0.9.12.

gensym ay ginagamit upang bumuo ng isang natatanging simbolo na nagpapahintulot sa mga macro na maisulat nang wala
hindi sinasadyang pag-aaway ng pangalan ng variable.

=> (gensym)
u':G_1235'

=> (gensym "x")
u':x_1236'

TINGNAN DIN:
Seksyon gamit ang-gensym

makuha
makuha ay ginagamit upang ma-access ang mga solong elemento sa mga listahan at diksyunaryo. makuha tumatagal ng dalawang parameter:
ang data kaayusan at ang index or susi ng item. Pagkatapos ay ibabalik nito ang kaukulang
halaga mula sa diksyunaryo o sa listahan. Halimbawa ng paggamit:

=> (hayaan [[mga hayop {"aso" "kuhol" "pusa" "meow"}]
... [mga numero ["zero" "isa" "dalawa" "tatlo"]]]
... (i-print (kumuha ng mga hayop "aso"))
... (i-print (kumuha ng mga numero 2)))
kangkang
dalawa

TANDAAN:
makuha itataas ang isang KeyError kung ang isang diksyunaryo ay tinanong para sa isang hindi umiiral na key.

TANDAAN:
makuha nagtataas ng IndexError kung ang isang listahan o isang tuple ay na-query para sa isang index na wala sa
hangganan

global
global maaaring gamitin upang markahan ang isang simbolo bilang global. Ito ay nagpapahintulot sa programmer na magtalaga ng a
halaga sa isang pandaigdigang simbolo. Ang pagbabasa ng isang pandaigdigang simbolo ay hindi nangangailangan ng global keyword --
pagtatalaga lamang ang ginagawa nito.

Ang sumusunod na halimbawa ay nagpapakita kung paano ang pandaigdigang simbolo a ay itinalaga ng isang halaga sa isang function at
ay na-print sa ibang pagkakataon sa ibang function. Kung wala ang global keyword, ang pangalawang function
itatapon sana a PangalananError.

(defn set-a [value]
(pandaigdig a)
(setv isang halaga))

(defn print-a []
(print a))

(set-a 5)
(print-a)

if / kung hindi
Bago sa bersyon 0.10.0: kung-hindi

if ay ginagamit upang may kondisyong piliin ang code na isasagawa. Dapat itong maglaman ng isang kundisyon
block at ang block na isasagawa kung ang condition block ay susuriin sa Totoo. Opsyonal,
maaaring naglalaman ito ng panghuling bloke na isasagawa kung sakaling ang pagsusuri ng kundisyon ay
Huwad.

kung hindi ay katulad, ngunit ang pangalawang bloke ay isasagawa kapag nabigo ang kundisyon habang
ang ikatlo at panghuling bloke ay isasagawa kapag nagtagumpay ang pagsubok -- ang kabaligtaran ng pagkakasunud-sunod ng if.

Halimbawa ng paggamit:

(kung (naiwan ng pera? account)
(i-print ang "tara na mamili")
(i-print ang "tara na at magtrabaho"))

(kung-hindi (pera-naiwan? account)
(i-print ang "tara na at magtrabaho")
(i-print ang "tara na mamili"))

Ang katotohanan ng Python ay iginagalang. Wala, Huwad, zero ng anumang uri ng numero, isang walang laman na pagkakasunod-sunod,
at ang isang walang laman na diksyunaryo ay isinasaalang-alang Huwad; lahat ng iba pa ay isinasaalang-alang Totoo.

lisp-kung / elevator at lisp-kung-hindi / buhay-hindi
Bago sa bersyon 0.10.0.

Bago sa bersyon 0.10.2: lisp-if-not / lif-not

Para sa mga mas gusto ng mas Lispy if sugnay, mayroon kami lisp-kung, O elevator. ito lamang isinasaalang-alang
Wala / kawalan maging huwad! Ang lahat ng iba pang "false-ish" na halaga ng Python ay itinuturing na totoo.
Sa kabaligtaran, mayroon kami lisp-kung-hindi at buhay-hindi kahanay sa if at kung hindi na binabaligtad
ang pagkukumpara.

=> (lisp-if True "true" "false")
"totoo"
=> (lisp-if False "true" "false")
"totoo"
=> (lisp-if 0 "true" "false")
"totoo"
=> (lisp-if nil "true" "false")
"false"
=> (lisp-kung Wala "true" "false")
"false"
=> (lisp-if-not nil "true" "false")
"totoo"
=> (lisp-if-not Wala "true" "false")
"totoo"
=> (lisp-if-not Mali "totoo" "mali")
"false"

; Katumbas ngunit mas maikli
=> (buhay True "true" "false")
"totoo"
=> (lif nil "true" "false")
"false"
=> (lif-not None "true" "false")
"totoo"

angkat
angkat ay ginagamit upang mag-import ng mga module, tulad ng sa Python. Mayroong ilang mga paraan na angkat maaari
magamit.

;; Ini-import ang bawat isa sa mga module na ito
;;
;; sawa:
;; import sys
;; import os.path
(import sys os.path)

;; Mag-import mula sa isang module
;;
;; Python: mula sa os.path import ay umiiral, isdir, isfile
(import [os.path [umiiral isdir isfile]])

;; Mag-import gamit ang isang alias
;;
;; Python: import sys bilang systest
(import [sys :as systest])

;; Maaari kang maglista ng maraming pag-import hangga't gusto mo ng iba't ibang uri.
(import [tests.resources [kwtest function-with-a-dash]]
[os.path [umiiral ang isdir isfile]]
[sys:as systest])

;; I-import ang lahat ng mga function ng module sa kasalukuyang namespace
(import [sys [*]])

lambda / fn
lambda at fn ay maaaring gamitin upang tukuyin ang isang hindi kilalang function. Ang mga parameter ay katulad ng
defn: ang unang parameter ay vector ng mga parameter at ang natitira ay ang katawan ng
function. lambda nagbabalik ng bagong function. Sa sumusunod na halimbawa, isang hindi kilalang function
ay tinukoy at ipinasa sa isa pang function para sa pag-filter ng output.

=> (def people [{:name "Alice" :edad 20}
... {:name "Bob" :edad 25}
... {:name "Charlie" :edad 50}
... {:pangalan "Dave" :edad 5}])

=> (defn display-people [filter ng mga tao]
... (para sa [tao na tao] (kung (i-filter ang tao) (i-print (:pangalan ng tao)))))

=> (display-people people (fn [tao] (< (:age person) 25)))
Alice
Dave

Tulad ng sa normal na mga kahulugan ng function, kung ang unang elemento ng katawan ay isang string, ito
nagsisilbing docstring. Ito ay kapaki-pakinabang para sa pagbibigay ng mga docstring ng mga pamamaraan ng klase.

=> (setv beses-tatlo
... (fn [x]
... "Dumarami ng input sa tatlo at ibinabalik ang resulta."
... (* x 3)))

Maaari itong kumpirmahin sa pamamagitan ng built-in na Python Tulungan pag-andar:

=> (help times-three)
Tulong sa function times_three:

beses_tatlo(x)
I-multiply ang input sa tatlo at ibinabalik ang resulta
(WAKAS)

huli
Bago sa bersyon 0.10.2.

huli ay maaaring gamitin para sa pag-access sa huling elemento ng isang koleksyon:

=> (huling [2 4 6])
6

pabayaan
pabayaan ay ginagamit upang lumikha ng lexically scoped variable. Ang mga ito ay nilikha sa simula ng
pabayaan form at hindi na umiral pagkatapos ng form. Ang sumusunod na halimbawa ay nagpapakita nito
pag-uugali:

=> (hayaan [[x 5]] (i-print x)
... (hayaan [[x 6]] (i-print x))
... (print x))
5
6
5

Ang pabayaan Ang macro ay tumatagal ng dalawang parameter: isang vector na pagtukoy mga variable at ang katawan na nakakakuha
pinatay. mga variable ay isang vector kung saan ang bawat elemento ay alinman sa isang variable o isang vector
pagtukoy ng variable na pares ng halaga. Sa kaso ng isang variable, ito ay itinalagang halaga
Wala; kung hindi, ang ibinigay na halaga ay ginagamit.

=> (hayaan [x [y 5]] (print xy))
Wala 5

listahan-comp
listahan-comp nagsasagawa ng mga pag-unawa sa listahan. Ito ay tumatagal ng dalawa o tatlong mga parameter. Ang una
Ang parameter ay ang expression na kumokontrol sa return value, habang ang pangalawa ay ginagamit upang
pumili ng mga item mula sa isang listahan. Ang pangatlo at opsyonal na parameter ay maaaring gamitin upang i-filter ang ilan
ng mga item sa listahan batay sa isang conditional expression. Ilang halimbawa:

=> (def collection (saklaw 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]

hindi
hindi ay ginagamit sa mga lohikal na pagpapahayag. Ito ay tumatagal ng isang parameter at nagbabalik ng isang baligtad
halaga ng katotohanan. Kung Totoo ay ibinigay bilang isang parameter, Huwad ay ibabalik, at kabaliktaran.
Halimbawa ng paggamit:

=> (hindi Totoo)
Huwad

=> (hindi Mali)
Totoo

=> (hindi Wala)
Totoo

or
or ay ginagamit sa mga lohikal na pagpapahayag. Ito ay tumatagal ng hindi bababa sa dalawang mga parameter. Ibabalik nito ang
unang hindi maling parameter. Kung walang ganoong halaga, ibabalik ang huling parameter.

=> (o True False)
Totoo

=> (at Mali Mali)
Huwad

=> (at False 1 True False)
1

TANDAAN:
or short-circuits at huminto sa pagsusuri ng mga parameter sa sandaling ang unang tunay na halaga ay
nakatagpo.

=> (o Tama (i-print ang "hello"))
Totoo

i-print
i-print ay ginagamit upang mag-output sa screen. Halimbawa ng paggamit:

(i-print ang "Hello world!")

TANDAAN:
i-print laging bumabalik Wala.

parang quote
parang quote nagbibigay-daan sa iyo na mag-quote ng isang form, ngunit piling suriin din ang mga expression.
Mga ekspresyon sa loob a parang quote maaaring piliing suriin gamit ang magpahayag (~). Ang
ang nasuri na anyo ay maaari ding idugtong gamit ang unquote-splice (~@). Quasiquote ay maaari ding
isinulat gamit ang backquote (`) simbolo.

;; hayaan ang `qux' na maging isang variable na may halaga (bar baz)
`(foo ~qux)
; katumbas ng '(foo (bar baz))
`(foo ~@qux)
; katumbas ng '(foo bar baz)

sipi
sipi ibinabalik ang form na ipinasa dito nang hindi sinusuri ito. sipi ay maaaring maging
isinulat gamit ang apostrophe (') simbolo.

=> (setv x '(print "Hello World"))
; Ang variable x ay nakatakda sa expression at hindi sinusuri
=> x
(u'print' u'Hello World')
=> (eval x)
Kamusta Mundo

mangailangan
mangailangan ay ginagamit upang mag-import ng mga macro mula sa isang ibinigay na module. Ito ay tumatagal ng hindi bababa sa isang parameter
pagtukoy sa module kung aling mga macro ang dapat i-import. Maaaring ma-import ang maramihang mga module
na may isang solong mangailangan.

Ang sumusunod na halimbawa ay mag-i-import ng mga macro mula sa modyul-1 at modyul-2:

(nangangailangan ng module-1 module-2)

pahinga / Cdr
pahinga at Cdr ibalik ang koleksyon na ipinasa bilang isang argumento nang walang unang elemento:

=> (pahinga (saklaw 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

set-comp
set-comp ay ginagamit upang lumikha ng mga set. Ito ay tumatagal ng dalawa o tatlong mga parameter. Ang unang parameter ay
para sa pagkontrol sa return value, habang ang pangalawa ay ginagamit para pumili ng mga item mula sa a
pagkakasunod-sunod. Maaaring gamitin ang pangatlo at opsyonal na parameter para i-filter ang ilan sa mga item sa loob
ang sequence batay sa isang conditional expression.

=> (setv data [1 2 3 4 5 2 3 4 5 3 4 5])
=> (set-comp x [x data] (kakaiba? x))
{1, 3, 5}

pagpira-pirasuhin
pagpira-pirasuhin ay maaaring gamitin upang kumuha ng subset ng isang listahan at gumawa ng bagong listahan mula dito. Ang porma
tumatagal ng hindi bababa sa isang parameter na tumutukoy sa listahan upang hatiin. Dalawang opsyonal na parameter ang maaaring
ginamit upang ibigay ang panimula at wakas na posisyon ng subset. Kung hindi sila ibinibigay, ang
default na halaga ng Wala sa halip ay gagamitin. Ang ikatlong opsyonal na parameter ay ginagamit upang
hakbang ng kontrol sa pagitan ng mga elemento.

pagpira-pirasuhin sumusunod sa parehong mga patakaran tulad ng katapat nitong Python. Ang mga negatibong indeks ay binibilang
simula sa dulo ng listahan. Ilang halimbawa ng paggamit:

=> (def collection (saklaw 10))

=> (slice collection)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=> (slice collection 5)
[5, 6, 7, 8, 9]

=> (slice collection 2 8)
[2, 3, 4, 5, 6, 7]

=> (slice collection 2 8 2)
[2, 4, 6]

=> (slice collection -4 -2)
[6, 7]

ihagis / taasan
Ang ihagis or taasan ang mga form ay maaaring gamitin upang itaas ang isang Exception sa runtime. Halimbawa ng paggamit:

(ihagis)
; re-rase ang huling exception

(ihagis ang IOError)
; Magtapon ng IOError

(ihagis (IOError "foobar"))
; Magtapon ng IOError("foobar")

ihagis maaaring tumanggap ng isang argumento (an Exception klase o halimbawa) o walang argumento sa
muling itaas ang huli Exception.

sumubok
Ang sumubok ginagamit ang form upang simulan ang a sumubok / abutin harangan. Ang form ay ginagamit tulad ng sumusunod:

(subukan
(error-prone-function)
(mahuli ang [e ZeroDivisionError] (i-print ang "Division by zero"))
(iba pa (i-print ang "walang mga error"))
(sa wakas (i-print ang "tapos na lahat")))

sumubok dapat maglaman ng hindi bababa sa isa abutin block, at maaaring opsyonal na isama ang isang iba or sa wakas
harangan. Kung ang isang error ay nakataas na may katugmang catch block sa panahon ng pagpapatupad ng
error-prone-function, Na abutin ang block ay isasagawa. Kung walang mga error na itinaas, ang iba
ang block ay naisakatuparan. Ang sa wakas huling isasagawa ang block kahit na ang isang
naitaas ang error.

maliban na lamang kung
Ang maliban na lamang kung Ang macro ay isang shorthand para sa pagsulat ng isang if pahayag na nagsusuri kung ang ibinigay
kondisyon ay Huwad. Ipinapakita ng sumusunod ang pagpapalawak ng macro na ito.

(maliban kung may kondisyong pahayag)

(kung may kondisyon
Wala
(gawin ang pahayag))

magpahayag
Sa loob ng isang quasiquoted form, magpahayag pwersang pagsusuri ng isang simbolo. magpahayag ay naka-alyas sa
ang tilde (~) simbolo.

(def name na "Cuddles")
(quasiquote (= pangalan (unquote name)))
;=> (u'=' u'name' u'Cuddles')

`(= pangalan ~pangalan)
;=> (u'=' u'name' u'Cuddles')

unquote-splice
unquote-splice pinipilit ang pagsusuri ng isang simbolo sa loob ng isang quasiquoted form, katulad ng
magpahayag. unquote-splice magagamit lamang kapag ang simbolo na hindi sinipi ay naglalaman ng isang
iterable value, dahil ito ay "splices" na iterable sa quasiquoted form. unquote-splice is
alias sa ~@ simbolo.

(mga def num [1 2 3 4])
(quasiquote (+ (unquote-splice nums)))
;=> (u'+' 1L 2L 3L 4L)

`(+ ~@nums)
;=> (u'+' 1L 2L 3L 4L)

kailan
kailan ay katulad ng maliban na lamang kung, maliban kung ito ay sumusubok kapag ang ibinigay na kondisyon ay Totoo. Hindi ito
posibleng magkaroon ng isang iba harangan sa a kailan macro. Ang mga sumusunod ay nagpapakita ng pagpapalawak ng
macro.

(kapag may kondisyong pahayag)

(kung may kondisyon (gawin ang pahayag))

habang
habang ay ginagamit upang magsagawa ng isa o higit pang mga bloke hangga't natutugunan ang isang kundisyon. Ang mga sumusunod
ang halimbawa ay maglalabas ng "Hello world!" sa screen nang walang katapusan:

(habang Tama (i-print ang "Hello world!"))

sa
sa ay ginagamit upang i-wrap ang pagpapatupad ng isang block sa loob ng isang context manager. Ang konteksto
maaaring i-set up ng manager ang lokal na sistema at sirain ito sa isang kontroladong paraan. Ang
archetypical halimbawa ng paggamit sa ay kapag nagpoproseso ng mga file. sa maaaring magbigkis ng konteksto sa isang
argumento o balewalain ito nang buo, tulad ng ipinapakita sa ibaba:

(na may [[arg (expr)]] block)

(na may [[(expr)]] block)

(na may [[arg (expr)] [(expr)]] block)

Ang sumusunod na halimbawa ay magbubukas ng BALITA file at i-print ang nilalaman nito sa screen. Ang
Ang file ay awtomatikong isinara pagkatapos itong maproseso.

(na may [[f (open "NEWS")]] (print (.read f)))

may-dekorador
may-dekorador ay ginagamit upang i-wrap ang isang function sa isa pa. Ang function na gumaganap ng
dapat tanggapin ng dekorasyon ang isang solong halaga: ang function na pinalamutian, at magbalik ng bago
function. may-dekorador tumatagal ng hindi bababa sa dalawang parameter: gumaganap ang function
palamuti at ang function na pinalamutian. Maaaring maging higit sa isang function ng dekorador
inilapat; ilalapat ang mga ito sa pagkakasunud-sunod mula sa labas hanggang sa pinakaloob, ibig sabihin. ang una
dekorador ang magiging pinakalabas, at iba pa. Ang mga dekorador na may mga argumento ay tinatawag na makatarungan
parang function call.

(with-decorator decorator-fun
(defn some-function [] ...)

(may-dekorador dekorador1 dekorador2 ...
(defn some-function [] ...)

(may-dekorasyon (dekorador arg) ..
(defn some-function [] ...)

Sa sumusunod na halimbawa, inc-dekorador ay ginagamit upang palamutihan ang function dagdag na may isang
function na kumukuha ng dalawang parameter at tinatawag ang pinalamutian na function na may mga value na
dinagdagan ng 1. Kapag ang ginayakan dagdag ay tinatawag na may mga halaga 1 at 1, ang dulo
ang magiging resulta ay 4 (1 + 1 + 1 + 1).

=> (defn inc-decorator [func]
... (fn [value-1 value-2] (func (+ value-1 1) (+ value-2 1))))
=> (defn inc2-decorator [func]
... (fn [value-1 value-2] (func (+ value-1 2) (+ value-2 2))))

=> (may-decorator inc-decorator (defn karagdagan [ab] (+ ab)))
=> (dagdag 1 1)
4
=> (with-decorator inc2-decorator inc-decorator
... (defn karagdagan [ab] (+ ab)))
=> (dagdag 1 1)
8

may-gensyms
Bago sa bersyon 0.9.12.

may-gensym ay ginagamit upang makabuo ng isang set ng gensym para gamitin sa isang macro. Ang sumusunod na code:

(may-gensyms [abc]
...)

lumalawak sa:

(hayaan [[a (gensym)
[b (gensym)
[c (gensym)]]
...)

TINGNAN DIN:
Seksyon gamit ang-gensym

ani
ani ay ginagamit upang lumikha ng isang generator object na nagbabalik ng isa o higit pang mga halaga. Ang generator
ay iterable at samakatuwid ay maaaring gamitin sa mga loop, listahan ng mga pag-unawa at iba pang katulad
mga konstruksyon.

Ang function na mga random na numero nagpapakita kung paano magagamit ang mga generator upang makabuo ng walang katapusang serye
nang walang pag-ubos ng walang katapusang dami ng memorya.

=> (defn multiply [binabatay ang mga coefficient]
... (para sa [[(, base coefficient) (zip bases coefficients)]]
... (yield (* base coefficient))))

=> (multiply (range 5) (range 5))


=> (list-comp value [value (multiply (range 10)) (range 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (i-import ng random)
=> (defn random-numbers [mababa ang taas]
... (habang Tama (nagbubunga (.randint random low high))))
=> (list-comp x [x (kumuha ng 15 (mga random na numero 1 50))])])
[7, 41, 6, 22, 32, 17, 5, 38, 18, 38, 17, 14, 23, 23, 19]

ani-mula sa
Bago sa bersyon 0.9.13.

PYTHON 3.3 AT UP LAMANG!

ani-mula sa ay ginagamit upang tawagan ang isang subgenerator. Ito ay kapaki-pakinabang kung gusto mo ang iyong coroutine
magagawang italaga ang mga proseso nito sa isa pang coroutine, halimbawa, kung gumagamit ng isang magarbong tulad
asyncio.

Hy Ubod
Ubod Pag-andar
butlast
Paggamit ng: (pero huli coll)

Nagbabalik ng isang iterator ng lahat maliban sa huling item sa coll.

=> (listahan (butlast (saklaw 10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8]

=> (listahan (butlast [1]))
[]

=> (listahan (butlast []))
[]

=> (import itertools)
=> (listahan (kumuha ng 5 (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

coll?
Bago sa bersyon 0.10.0.

Paggamit ng: (coll? x)

Kita Totoo if x ay iterable at hindi isang string.

=> (coll? [1 2 3 4])
Totoo

=> (coll? {"a" 1 "b" 2})
Totoo

=> (coll? "abc")
Huwad

cons
Bago sa bersyon 0.10.0.

Paggamit ng: (cons a b)

Nagbabalik ng bagong cons cell na may kotse a at cdr b.

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

=> (= 'hd (kotse a))
Totoo

=> (= 'tl (cdr a))
Totoo

cons?
Bago sa bersyon 0.10.0.

Paggamit ng: (cons? foo)

Sinusuri kung foo ay isang cons cell.

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

=> (cons? a)
Totoo

=> (cons? wala)
Huwad

=> (cons? [1 2 3])
Huwad

Disyembre
Paggamit ng: (dec x)

Nagbabalik ng isang mas mababa sa x. Katumbas ng (- x 1). Nagtataas Pagkakamali sa pagtype if (Hindi (numero? x)).

=> (Disyembre 3)
2

=> (Disyembre 0)
-1

=> (Disyembre 12.3)
11.3

pagtanggal-tanggalin
Bago sa bersyon 0.10.0.

Paggamit ng: (i-disassemble puno &opsyonal [codegen mali])

Itapon ang Python AST para sa ibinigay na Hy puno sa karaniwang output. Kung codegen is Totoo, ang function
nagpi-print ng Python code sa halip.

=> (i-disassemble '(i-print ang "Hello World!"))
Module(
katawan=[
Expr(value=Call(func=Name(id='print'), args=[Str(s='Hello World!')], keywords=[], starargs=None, kwargs=None))])

=> (i-disassemble '(i-print ang "Hello World!") true)
print('Hello World!')

walang laman?
Paggamit ng: (walang laman? coll)

Kita Totoo if coll ay walang laman. Katumbas ng (= 0 (len magkagulo)).

=> (walang laman? [])
Totoo

=> (walang laman? "")
Totoo

=> (walang laman? (, 1 2))
Huwad

bawat?
Bago sa bersyon 0.10.0.

Paggamit ng: (bawat? pred coll)

Kita Totoo if (pred x) ay lohikal na totoo para sa bawat x in coll, Kung hindi man Huwad. Bumalik Totoo
if coll walang laman.

=> (bawat? kahit? [2 4 6])
Totoo

=> (bawat? kahit? [1 3 5])
Huwad

=> (bawat? kahit? [2 4 5])
Huwad

=> (bawat? kahit? [])
Totoo

lumutang?
Paggamit ng: (lumutang? x)

Kita Totoo if x ay isang float.

=> (lumutang? 3.2)
Totoo

=> (lumutang? -2)
Huwad

kahit?
Paggamit ng: (kahit? x)

Kita Totoo if x ay pantay. Nagtataas Pagkakamali sa pagtype if (Hindi (numero? x)).

=> (kahit? 2)
Totoo

=> (kahit? 13)
Huwad

=> (kahit? 0)
Totoo

pagkakakilanlan
Paggamit ng: (pagkakakilanlan x)

Ibinabalik ang argument na ibinigay sa function.

=> (pagkakakilanlan 4)
4

=> (listahan (mapa pagkakakilanlan [1 2 3 4]))
[1 2 3 4]

Inc
Paggamit ng: (inc x)

Nagbabalik ng isa higit sa x. Katumbas ng (+ x 1). Nagtataas Pagkakamali sa pagtype if (Hindi (numero? x)).

=> (inc 3)
4

=> (inc 0)
1

=> (inc 12.3)
13.3

halimbawa?
Paggamit ng: (halimbawa? klase x)

Kita Totoo if x ay isang halimbawa ng klase.

=> (halimbawa? float 1.0)
Totoo

=> (halimbawa? int 7)
Totoo

=> (halimbawa? str (str "foo"))
Totoo

=> (defclass TestClass [object])
=> (setv inst (TestClass))
=> (halimbawa? TestClass inst)
Totoo

integer?
Paggamit ng: (integer? x)

Kita Totoo if x ay isang integer. Para sa Python 2, ito ay alinman int or mahaba. Para sa Python 3,
ito ay int.

=> (integer? 3)
Totoo

=> (integer? -2.4)
Huwad

interleave
Bago sa bersyon 0.10.1.

Paggamit ng: (mag-interleave seq1 seq2 ...)

Nagbabalik ng iterable ng unang item sa bawat isa sa mga sequence, pagkatapos ay ang pangalawa, atbp.

=> (listahan (interleave (saklaw 5) (saklaw 100 105)))
[0, 100, 1, 101, 2, 102, 3, 103, 4, 104]

=> (listahan (interleave (saklaw 1000000) "abc"))
[0, 'a', 1, 'b', 2, 'c']

interpose
Bago sa bersyon 0.10.1.

Paggamit ng: (i-interpose bagay seq)

Nagbabalik ng iterable ng mga elemento ng sequence na pinaghihiwalay ng item.

=> (listahan (ipasok ang "!" "abcd"))
['a B C D']

=> (listahan (interpose -1 (saklaw 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

iterable?
Paggamit ng: (iterable? x)

Kita Totoo if x ay iterable. Ang mga iterable na bagay ay nagbabalik ng bagong iterator kapag (iter x) is
tinawag. Kaibahan sa iterator?.

=> ;; gumagana para sa mga string
=> (iterable? (str "abcde"))
Totoo

=> ;; gumagana para sa mga listahan
=> (iterable? [1 2 3 4 5])
Totoo

=> ;; gumagana para sa tuples
=> (iterable? (, 1 2 3))
Totoo

=> ;; gumagana para sa dicts
=> (iterable? {:a 1 :b 2 :c 3})
Totoo

=> ;; gumagana para sa mga iterator/generator
=> (iterable? (ulitin 3))
Totoo

iterator?
Paggamit ng: (iterator? x)

Kita Totoo if x ay isang iterator. Ang mga iterator ay mga bagay na nagbabalik sa kanilang sarili bilang isang
iterator kung kailan (iter x) ay tinatawag na. Kaibahan sa iterable?.

=> ;; ay hindi gumagana para sa isang listahan
=> (iterator? [1 2 3 4 5])
Huwad

=> ;; ngunit makakakuha tayo ng isang iter mula sa listahan
=> (iterator? (iter [1 2 3 4 5]))
Totoo

=> ;; hindi gumagana para sa dict
=> (iterator? {:a 1 :b 2 :c 3})
Huwad

=> ;; lumikha ng isang iterator mula sa dict
=> (iterator? (iter {:a 1 :b 2:c 3}))
Totoo

listahan*
Paggamit ng: (listahan* ulo &magpahinga buntot)

Bumubuo ng isang hanay ng mga nested cons cell (isang tuldok na listahan) na naglalaman ng mga argumento. Kung ang
Ang listahan ng argumento ay mayroon lamang isang elemento, ibalik ito.

=> (listahan* 1 2 3 4)
(1 2 3 . 4)

=> (listahan* 1 2 3 [4])
[1, 2, 3, 4]

=> (listahan* 1)
1

=> (cons? (listahan* 1 2 3 4))
Totoo

macroexpand
Bago sa bersyon 0.10.0.

Paggamit ng: (macroexpand anyo)

Ibinabalik ang buong macro expansion ng anyo.

=> (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')

macroexpand-1
Bago sa bersyon 0.10.0.

Paggamit ng: (macroexpand-1 anyo)

Ibinabalik ang solong hakbang na macro expansion ng anyo.

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

sumanib sa
Bago sa bersyon 0.10.1.

Paggamit ng: (sumanib sa f &magpahinga mapa)

Ibinabalik ang isang mapa na binubuo ng iba pang mga mapa na unang pinagsamahan. Kung may naganap na susi sa
higit sa isang mapa, ang (mga) pagmamapa mula sa huli (kaliwa-pakanan) ay isasama sa
ang pagmamapa sa resulta sa pamamagitan ng pagtawag (f val-in-resulta val-in-latter).

=> (merge-with (fn [xy] (+ xy)) {"a" 10 "b" 20} {"a" 1 "c" 30})
{u'a': 11L, u'c': 30L, u'b': 20L}

neg?
Paggamit ng: (neg? x)

Kita Totoo if x ay mas mababa sa zero. Nagtataas Pagkakamali sa pagtype if (Hindi (numero? x)).

=> (neg? -2)
Totoo

=> (neg? 3)
Huwad

=> (neg? 0)
Huwad

wala?
Paggamit ng: (wala? x)

Kita Totoo if x is kawalan / Wala.

=> (wala? wala)
Totoo

=> (wala? Wala)
Totoo

=> (wala? 0)
Huwad

=> (setf x nil)
=> (wala? x)
Totoo

=> ;; list.append palaging nagbabalik Wala
=> (wala? (.idagdag [1 2 3] 4))
Totoo

wala?
Paggamit ng: (wala? x)

Kita Totoo if x is Wala.

=> (wala? Wala)
Totoo

=> (wala? 0)
Huwad

=> (setf x Wala)
=> (wala? x)
Totoo

=> ;; list.append palaging nagbabalik Wala
=> (wala? (.idagdag [1 2 3] 4))
Totoo

wala
Paggamit ng: (nth coll n &opsyonal [default wala])

Nagbabalik ang n-th item sa isang koleksyon, na nagbibilang mula sa 0. Ibalik ang default na halaga, kawalan, Kung
out of bounds (maliban kung tinukoy kung hindi man). Nagtataas ValueError if n ay negatibo.

=> (ika [1 2 4 7] 1)
2

=> (ika [1 2 4 7] 3)
7

=> (wala? (nth [1 2 4 7] 5))
Totoo

=> (nth [1 2 4 7] 5 "default")
'default'

=> (nth (kumuha ng 3 (drop 2 [1 2 3 4 5 6])) 2))
5

=> (ika [1 2 4 7] -1)
Traceback (pinakahuling huling tawag):
...
ValueError: Ang mga indeks para sa islice() ay dapat Wala o isang integer: 0 <= x <= sys.maxsize.

numero?
Paggamit ng: (numero? x)

Kita Totoo if x ay isang numeric, tulad ng tinukoy sa Python's numero.Bilang klase.

=> (numero? -2)
Totoo

=> (numero? 3.2)
Totoo

=> (numeric? "foo")
Huwad

kakaiba?
Paggamit ng: (kakaiba? x)

Kita Totoo if x ay kakaiba. Nagtataas Pagkakamali sa pagtype if (Hindi (numero? x)).

=> (kakaiba? 13)
Totoo

=> (kakaiba? 2)
Huwad

=> (kakaiba? 0)
Huwad

pos?
Paggamit ng: (pos? x)

Kita Totoo if x ay mas malaki sa zero. Nagtataas Pagkakamali sa pagtype if (Hindi (numero? x)).

=> (pos? 3)
Totoo

=> (pos? -2)
Huwad

=> (pos? 0)
Huwad

pangalawa
Paggamit ng: (pangalawa coll)

Ibinabalik ang pangalawang miyembro ng coll. Katumbas ng (kunin coll 1).

=> (pangalawa [0 1 2])
1

ilan
Bago sa bersyon 0.10.0.

Paggamit ng: (ilan pred coll)

Ibinabalik ang unang lohikal na tunay na halaga ng (pred x) para sa anumang x in coll, Kung hindi man kawalan.
Bumalik kawalan if coll walang laman.

=> (kahit ang ilan? [2 4 6])
Totoo

=> (wala? (kahit ang ilan? [1 3 5]))
Totoo

=> (wala? (ilang pagkakakilanlan [0 "" []]))
Totoo

=> (ilang pagkakakilanlan [0 "non-empty-string" []])
'non-empty-string'

=> (wala? (kahit ang ilan? []))
Totoo

string?
Paggamit ng: (kuwerdas? x)

Kita Totoo if x ay isang string.

=> (string? "foo")
Totoo

=> (string? -2)
Huwad

simbolo?
Paggamit ng: (simbolo? x)

Kita Totoo if x ay isang simbolo.

=> (simbolo? 'foo)
Totoo

=> (simbolo? '[abc])
Huwad

zero?
Paggamit ng: (zero? x)

Kita Totoo if x ay zero.

=> (zero? 3)
Huwad

=> (zero? -2)
Huwad

=> (zero? 0)
Totoo

Pagkakasunud-sunod Pag-andar
Ang mga function ng sequence ay maaaring lumikha o gumana sa isang potensyal na walang katapusang sequence nang wala
na nangangailangan ng pagkakasunud-sunod na ganap na maisakatuparan sa isang listahan o katulad na lalagyan. Ginagawa nila ito sa pamamagitan ng
nagbabalik ng Python iterator.

Maaari naming gamitin ang canonical infinite Fibonacci number generator bilang isang halimbawa kung paano gamitin
ilan sa mga function na ito.

(defn fib []
(setv a 0)
(setv b 1)
(habang totoo
(nagbubunga ng a)
(setv (, ab) (, b (+ ab)))))

Tandaan ang (habang totoo ...) loop. Kung patakbuhin natin ito sa REPL,

=> (fib)


Ang pagtawag sa function ay nagbabalik lamang ng isang iterator, ngunit hindi gagana hanggang sa ubusin natin ito.
Ang pagsubok ng isang bagay na tulad nito ay hindi inirerekomenda dahil ang walang katapusang loop ay tatakbo hanggang dito
Kumokonsumo ng lahat ng magagamit na RAM, o sa kasong ito hanggang sa mapatay ko ito.

=> (listahan (fib))
[1] 91474 ang pumatay kay hy

Upang makuha ang unang 10 numero ng Fibonacci, gamitin kumuha. Tandaan na kumuha nagbabalik din ng generator,
kaya gumawa ako ng listahan mula dito.

=> (listahan (kumuha ng 10 (fib)))
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Upang makuha ang numero ng Fibonacci sa index 9, (simula sa 0):

=> (nth (fib) 9)
34

ikot
Paggamit ng: (cycle coll)

Nagbabalik ng walang katapusang iterator ng mga miyembro ng coll.

=> (listahan (kumuha ng 7 (cycle [1 2 3])))
[1, 2, 3, 1, 2, 3, 1]

=> (listahan (kumuha ng 2 (cycle [1 2 3])))
[1, 2]

naiiba
Paggamit ng: (natatangi coll)

Nagbabalik ng iterator na naglalaman lamang ng mga natatanging miyembro coll.

=> (listahan (natatangi [ 1 2 3 4 3 5 2 ]))
[1, 2, 3, 4, 5]

=> (listahan (natatanging []))
[]

=> (listahan (natatangi (iter [ 1 2 3 4 3 5 2 ])))
[1, 2, 3, 4, 5]

ilaglag
Paggamit ng: (ihulog n coll)

Nagbabalik ng iterator, nilaktawan ang una n mga miyembro ng coll. Nagtataas ValueError if n is
negatibo.

=> (listahan (i-drop 2 [1 2 3 4 5]))
[3, 4, 5]

=> (listahan (i-drop 4 [1 2 3 4 5]))
[5]

=> (listahan (i-drop 0 [1 2 3 4 5]))
[1, 2, 3, 4, 5]

=> (listahan (i-drop 6 [1 2 3 4 5]))
[]

drop-huling
Paggamit ng: (huling pagbagsak n coll)

Nagbabalik ng isang iterator ng lahat maliban sa huli n mga item sa coll. Nagtataas ValueError if n is
negatibo.

=> (listahan (drop-huling 5 (saklaw 10 20)))
[10, 11, 12, 13, 14]

=> (listahan (drop-last 0 (range 5)))
[0, 1, 2, 3, 4]

=> (listahan (drop-last 100 (range 100)))
[]

=> (import itertools)
=> (listahan (kumuha ng 5 (i-drop-huling 100 (itertools.count 10)))))
[10, 11, 12, 13, 14]

drop-habang
Paggamit ng: (drop-while pred coll)

Nagbabalik ng iterator, nilaktawan ang mga miyembro ng coll hanggang pred is Huwad.

=> (listahan (i-drop-while even? [2 4 7 8 9]))
[7, 8, 9]

=> (listahan (drop-while numeric? [1 2 3 Wala "a"])))
[Wala, u'a']

=> (listahan (drop-while pos? [2 4 7 8 9]))
[]

filter
Paggamit ng: (filter pred coll)

Ibinabalik ang isang iterator para sa lahat ng mga item sa coll na pumasa sa panaguri pred.

Tingnan din alisin.

=> (listahan (filter pos? [1 2 3 -4 5 -7]))
[1, 2, 3, 5]

=> (listahan (i-filter kahit? [1 2 3 -4 5 -7]))
[2, -4]

patagin
Bago sa bersyon 0.9.12.

Paggamit ng: ( patagin coll)

Ibinabalik ang isang listahan ng lahat ng mga item sa coll, sa pamamagitan ng pag-flatte sa lahat ng nilalamang listahan at/o
tuples.

=> ( patagin [1 2 [3 4] 5])
[1, 2, 3, 4, 5]

=> (i-flatten ["foo" (, 1 2) [1 [2 3] 4] "bar"])
['foo', 1, 2, 1, 2, 3, 4, 'bar']

umulit
Paggamit ng: (ulitin fn x)

Nagbabalik ng iterator ng x, fn(x), fn(fn(x)), Atbp

=> (listahan (kumuha ng 5 (iterate inc 5)))
[5, 6, 7, 8, 9]

=> (listahan (kumuha ng 5 (ulitin (fn [x] (* xx)) 5)))
[5, 25, 625, 390625, 152587890625]

basahin
Paggamit ng: (basahin &opsyonal [mula sa file eof])

Binasa ang susunod na ekspresyon ng Hy mula sa mula sa file (naka-default sa sys.stdin), at maaaring tumagal ng a
solong byte bilang EOF (default sa isang walang laman na string). Nagtataas EOFError if mula sa file nagtatapos bago
maaaring ma-parse ang isang kumpletong expression.

=> (basahin)
(+ 2 2)
('+' 2 2)
=> (eval (basahin))
(+ 2 2)
4

=> (import io)
=> (def buffer (io.StringIO "(+ 2 2)\n(- 2 1)"))
=> (eval (ilapat ang read [] {"from_file" buffer}))
4
=> (eval (ilapat ang read [] {"from_file" buffer}))
1

=> ; sa pag-aakalang "example.hy" ay naglalaman ng:
=> ; (i-print ang "hello")
=> ; (i-print ang "hyfriends!")
=> (na may [[f (open "example.hy")]]
... (subukan
... (habang totoo
... (hayaan [[exp (basahin f)]]
... (gawin
... (i-print ang "OHY" exp)
... (eval exp))))
... (huli [e EOFError]
... (i-print ang "EOF!"))))
OHY ('print' 'hello')
hoy
OHY ('print' 'hyfriends!')
hyfriends!
EOF!

alisin
Paggamit ng: (alisin pred coll)

Nagbabalik ng iterator mula sa coll may mga elementong pumasa sa panaguri, pred, inalis.

Tingnan din filter.

=> (listahan (alisin ang kakaiba? [1 2 3 4 5 6 7]))
[2, 4, 6]

=> (listahan (alisin ang pos? [1 2 3 4 5 6 7]))
[]

=> (listahan (alisin ang neg? [1 2 3 4 5 6 7]))
[1, 2, 3, 4, 5, 6, 7]

ulitin
Paggamit ng: (ulitin x)

Nagbabalik ng isang iterator (walang katapusan) ng x.

=> (listahan (kumuha ng 6 (ulitin ang "mga")))
[u's', u's', u's', u's', u's', u's']

paulit-ulit
Paggamit ng: (paulit-ulit fn)

Nagbabalik ng iterator sa pamamagitan ng pagtawag fn paulit-ulit.

=> (import [random [randint]])

=> (listahan (kumuha ng 5 (paulit-ulit (fn [] (randint 0 10))))))
[6, 2, 0, 6, 7]

kumuha
Paggamit ng: (kunin n coll)

Nagbabalik ng iterator na naglalaman ng una n mga miyembro ng coll. Nagtataas ValueError if n is
negatibo.

=> (listahan (kumuha ng 3 [1 2 3 4 5]))
[1, 2, 3]

=> (listahan (kumuha ng 4 (ulitin ang "mga")))
[ikaw', ikaw', ikaw', ikaw']

=> (listahan (kumuha ng 0 (ulitin ang "mga")))
[]

take-nth
Paggamit ng: (kunin-nth n coll)

Nagbabalik ng iterator na naglalaman ng bawat n-ika-miyembro ng coll.

=> (listahan (take-nth 2 [1 2 3 4 5 6 7]))
[1, 3, 5, 7]

=> (listahan (take-nth 3 [1 2 3 4 5 6 7]))
[1, 4, 7]

=> (listahan (take-nth 4 [1 2 3 4 5 6 7]))
[1, 5]

=> (listahan (take-nth 10 [1 2 3 4 5 6 7]))
[1]

tumagal-habang
Paggamit ng: (sabay-sabay pred coll)

Nagbabalik ng iterator mula sa coll habang pred Babalik Totoo.

=> (listahan (take-while pos? [ 1 2 3 -4 5]))
[1, 2, 3]

=> (listahan (take-while neg? [ -4 -3 1 2 5]))
[-4, -3]

=> (listahan (take-while neg? [ 1 2 3 -4 5]))
[]

zipwith
Bago sa bersyon 0.9.13.

Paggamit ng: (zipwith fn coll ...)

Katumbas ng sigla, ngunit gumagamit ng multi-argument function sa halip na lumikha ng tuple. Kung
zipwith ay tinatawag na may N mga koleksyon, pagkatapos fn dapat tanggapin ang N argumento.

=> (operator ng pag-import)
=> (listahan (zipwith operator.add [1 2 3] [4 5 6]))
[5, 7, 9]

mambabasa Macros
Ang mga reader ng macro ay nagbibigay ng Lisp ng kapangyarihan upang baguhin at baguhin ang syntax sa mabilisang. ayaw mo
Polish notation? Madaling magagawa iyon ng isang reader macro. Gusto Clojure's paraan ng pagkakaroon ng isang
regex? Madali rin itong magagawa ng mga reader macro.

palaugnayan
=> (defreader ^ [expr] (print expr))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Kumusta"
"Kamusta"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

Walang literal si Hy para sa tuples. Sabihin nating ayaw mo (, ...) at gusto ng iba. Ito
ay isang problema na kayang lutasin ng mga macro reader sa isang maayos na paraan.

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

Maaari mo ring gawin ito tulad ng Clojure at magkaroon ng literal para sa mga regular na expression!

=> (import muli)
=> (defreader r [expr] `(re.compile ~expr))
=> #r".*"
<_sre.SRE_Pattern object sa 0xcv7713ph15#>

Pagsasakatuparan
defreader tumatagal ng isang character bilang pangalan ng simbolo para sa macro ng mambabasa; kahit ano pa
magbabalik ng error. Marunong sa pagpapatupad, defreader lumalawak sa isang lambda na natatakpan ng a
dekorador. Sine-save ng dekorador na ito ang lambda sa isang diksyunaryo kasama ang pangalan ng module nito at
simbolo.

=> (defreader ^ [expr] (print expr))
;=> (with_decorator (hy.macros.reader ^) (fn [expr] (print expr)))

# lumalawak sa (dispatch_reader_macro ...) kung saan ipinapasa ang simbolo at ekspresyon
ang tamang function.

=> #^()
;=> (dispatch_reader_macro ^ ())
=> #^"Kumusta"
"Kamusta"

BABALA:
Dahil sa isang limitasyon sa lexer at parser ni Hy, hindi maaaring muling tukuyin ng mga macro ng mambabasa ang tinukoy
syntax tulad ng ()[]{}. Ito ay malamang na matugunan sa hinaharap.

Panloob Hy dokumentasyon
TANDAAN:
Ang mga bit na ito ay kadalasang kapaki-pakinabang para sa mga taong nagha-hack sa Hy mismo, ngunit maaari ding gamitin para sa
ang mga mas malalim na naghuhukay sa macro programming.

Hy Modellen
pagpapakilala sa Hy Modellen
Ang mga modelo ng Hy ay isang napakanipis na layer sa ibabaw ng mga regular na bagay sa Python, na kumakatawan sa pinagmulan ng Hy
code bilang data. Ang mga modelo ay nagdaragdag lamang ng impormasyon sa posisyon ng pinagmulan, at ilang mga pamamaraan
suportahan ang malinis na pagmamanipula ng Hy source code, halimbawa sa mga macro. Para makamit iyon
layunin, ang mga modelo ng Hy ay mga mix ng isang baseng klase ng Python at HyObject.

HyObject
hy.models.HyObject ay ang batayang klase ng mga modelo ng Hy. Ito ay nagpapatupad lamang ng isang pamamaraan, palitan,
na pumapalit sa pinagmumulan na posisyon ng kasalukuyang bagay sa ipinasa bilang argumento.
Nagbibigay-daan ito sa amin na subaybayan ang orihinal na posisyon ng mga expression na binago ng
macros, maging iyon sa compiler o sa purong hy macros.

HyObject ay hindi nilayon na gamitin nang direkta upang i-instantiate ang mga modelo ng Hy, ngunit bilang isang mixin lamang
para sa ibang klase.

Compound Modellen
Ang mga naka-parentesis at naka-bracket na listahan ay na-parse bilang mga modelo ng tambalan ng Hy parser.

HyList
hy.models.list.HyList ay ang batayang klase ng "iterable" na mga modelo ng Hy. Ang pangunahing gamit nito ay upang
kumakatawan sa naka-bracket [] mga listahan, kung saan, kapag ginamit bilang isang nangungunang antas ng expression, isasalin sa
Ang mga literal na listahan ng Python sa yugto ng compilation.

Ang pagdaragdag ng HyList sa isa pang iterable object ay muling ginagamit ang klase ng left-hand-side object,
isang kapaki-pakinabang na pag-uugali kapag gusto mong pagsamahin ang mga Hy object sa isang macro, halimbawa.

HyExpression
hy.models.expression.HyExpression nagmamana HyList para sa panaklong () mga ekspresyon. Ang
Ang resulta ng compilation ng mga expression na iyon ay depende sa unang elemento ng listahan: ang
Nagpapadala ang compiler ng mga expression sa pagitan ng mga espesyal na form ng compiler, mga macro na tinukoy ng user, at
regular na tawag sa function ng Python.

HyDict
hy.models.dict.HyDict nagmamana HyList para sa kulot na naka-bracket {} mga expression, na pinagsama-sama
hanggang sa literal na diksyunaryo ng Python.

Ang pagpapasya sa paggamit ng isang listahan sa halip na isang dict bilang base class para sa HyDict nagbibigay-daan sa mas madali
pagmamanipula ng mga dict sa mga macro, na may dagdag na benepisyo ng pagpayag sa mga compound expression
bilang mga dict key (bilang, halimbawa, ang HyExpression Ang klase ng Python ay hindi hashable).

Atomiko Modellen
Sa input stream, double-quoted na mga string, na iginagalang ang Python notation para sa mga string,
ay na-parse bilang isang token, na direktang na-parse bilang a HyString.

Isang walang patid na string ng mga character, hindi kasama ang mga puwang, bracket, quote, double-quotes
at mga komento, ay na-parse bilang isang identifier.

Naresolba ang mga identifier sa mga atomic na modelo sa yugto ng pag-parse sa sumusunod na pagkakasunud-sunod:

· HyInteger

· HyFloat

· HyComplex (kung ang atom ay hindi hubad j)

· HyKeyword (kung ang atom ay nagsisimula sa :)

· HySymbol

HyString
hy.models.string.HyString ay ang batayang klase ng mga modelong Hy na katumbas ng string. Ito rin
kumakatawan sa double-quoted string literals, "", na nag-compile pababa sa unicode string
literal sa Python. HyStrings magmana ng mga unicode object sa Python 2, at string objects sa
Python 3 (at samakatuwid ay hindi umaasa sa pag-encode).

HyString ang mga nakabatay sa modelo ay hindi nababago.

Ang mga hy literal na string ay maaaring sumasaklaw sa maraming linya, at itinuturing ng parser bilang iisa
unit, na iginagalang ang Python escapes para sa mga unicode string.

Numeric Modellen
hy.models.integer.HyInteger kumakatawan sa mga literal na integer (gamit ang mahaba mag-type sa Python 2,
at int sa Python 3).

hy.models.float.HyFloat kumakatawan sa mga floating-point na literal.

hy.models.complex.HyComplex kumakatawan sa mga kumplikadong literal.

Ang mga numeric na modelo ay na-parse gamit ang kaukulang Python routine, at valid na numeric python
ang mga literal ay gagawing kanilang Hy counterpart.

HySymbol
hy.models.symbol.HySymbol ay ang modelong ginamit upang kumatawan sa mga simbolo sa wikang Hy. Ito
nagmamana HyString.

HySymbol ang mga bagay ay nasira sa yugto ng pag-parse, upang matulungan ang interoperability ng Python:

· Mga simbolo na napapalibutan ng mga asterisk (*) ay ginawang uppercase;

· Mga gitling (-) ay ginawang mga salungguhit (_);

· Isang sumusunod na tandang pananong (?) ay ginawang nangunguna ay_.

Caveat: dahil ginagawa ang mangling sa yugto ng pag-parse, posible na
programmatically bumuo ng HySymbols na hindi mabuo gamit ang Hy source code. Ang nasabing a
mekanismo ay ginagamit ng gensym upang makabuo ng mga "hindi naka-internet" na mga simbolo.

HyKeyword
hy.models.keyword.HyKeyword kumakatawan sa mga keyword sa Hy. Ang mga keyword ay mga simbolo na nagsisimula sa
a :. Nagmana ang klase HyString.

Upang makilala Mga HyKeyword mula Mga HySymbols, nang walang posibilidad ng (hindi sinasadya)
clashes, ang pribadong gamit na unicode na character "\uFDD0" ay inilalagay sa literal na keyword
bago mag-imbak.

Kahinaan Cell
hy.models.cons.HyCons ay isang representasyon ng Python-friendly cons cell. Ang mga cons cell ay
partikular na kapaki-pakinabang upang gayahin ang mga feature ng "karaniwan" na mga variant ng LISP gaya ng Scheme o Common
Lisp.

Ang cons cell ay isang 2-item na bagay, na naglalaman ng a kotse (ulo) at a Cdr (buntot). Sa ilang Lisp
mga variant, ang cons cell ay ang pangunahing bloke ng gusali, at ang mga S-expression ay talagang
kinakatawan bilang mga naka-link na listahan ng mga cons cell. Hindi ito ang kaso sa Hy, gaya ng dati
Ang mga expression ay gawa sa mga listahan ng Python na nakabalot sa a HyExpression. Gayunpaman, ang Mga HyCon
ginagaya ang pag-uugali ng "karaniwan" na mga variant ng Lisp nang ganito:

· (cons isang bagay wala) is (HyExpression [isang bagay])

· (cons isang bagay ilang-listahan) is ((uri ilang-listahan) (+ [isang bagay] ilang-listahan)) (kung
ilang-listahan namamana mula sa listahan).

· (kunin (cons a b) 0) is a

· (hiwain (cons a b) 1) is b

Sinusuportahan ni Hy ang isang dotted-list syntax, kung saan '(a . b) paraan (cons 'a 'b) at '(a b . c) paraan
(cons 'a (cons 'b 'c)). Kung ang compiler ay nakatagpo ng isang cons cell sa pinakamataas na antas, ito ay tumataas
isang error sa compilation.

Mga HyCon binabalot ang mga naipasa na argumento (kotse at cdr) sa mga uri ng Hy, upang mapagaan ang pagmamanipula ng
cons cell sa isang macro context.

Hy Panloob Teorya
Pangkalahatang-ideya
Ang mga panloob na Hy ay gumagana sa pamamagitan ng pagkilos bilang isang front-end sa Python bytecode, upang ang Hy mismo
nag-compile pababa sa Python Bytecode, na nagpapahintulot sa isang hindi nabagong Python runtime na magpatakbo ng Hy code,
nang hindi man lang napapansin.

Ang paraan ng paggawa nito ay sa pamamagitan ng pagsasalin ng Hy sa isang panloob na istruktura ng data ng Python AST, at
pagbuo ng AST na iyon pababa sa Python bytecode gamit ang mga module mula sa pamantayang Python
library, nang sa gayon ay hindi na namin kailangang i-duplicate ang lahat ng gawain ng Python internals para sa bawat
nag-iisang paglabas ng Python.

Gumagana si Hy sa apat na yugto. Sasaklawin ng mga sumusunod na seksyon ang bawat hakbang ng Hy mula sa pinagmulan hanggang
runtime.

Hakbang na 1 at 2: Tokenizing at Nagpaparada
Ang unang yugto ng pag-compile ng Hy ay ang pag-lex ng source sa mga token na maaari nating harapin. Kami
gumamit ng isang proyekto na tinatawag na rply, na isang talagang maganda (at mabilis) na parser, na nakasulat sa isang subset
ng Python na tinatawag na rpython.

Ang lexing code ay lahat ay tinukoy sa hy.lex.lexer. Ang code na ito ay kadalasang tumutukoy lamang sa Hy
grammar, at lahat ng aktwal na hard parts ay pinangangalagaan ng rply -- we just define
"mga callback" para sa rply in hy.lex.parser, na kumukuha ng mga token na nabuo, at ibinabalik ang
Hy mga modelo.

Maaari mong isipin ang mga modelong Hy bilang ang "AST" para kay Hy, ito ang pinapatakbo ng Macros
(direkta), at ito ang ginagamit ng compiler kapag kino-compile nito si Hy.

TINGNAN DIN:
seksyon Hy Modellen para sa higit pang impormasyon sa mga modelo ng Hy at kung ano ang ibig sabihin ng mga ito.

Hakbang 3: Hy Pagtitipon sa Sawa AST
Dito nangyayari ang karamihan sa magic sa Hy. Dito namin kinukuha ang Hy AST (ang mga modelo),
at i-compile ang mga ito sa Python AST. May ilang nakakatuwang bagay na nangyayari dito para matapos ang ilan
mga problema sa AST, at ang pagtatrabaho sa compiler ay ilan sa pinakamahalagang gawain na ginagawa namin
mayroon.

Ang compiler ay medyo kumplikado, kaya't huwag magdamdam kung hindi mo ito mahagilap sa unang pagbaril,
maaaring tumagal ng kaunting oras upang maging tama.

Ang pangunahing entry-point sa Compiler ay HyASTCompiler.compile. Ang pamamaraang ito ay ginagamit, at
ang tanging tunay na "pampubliko" na pamamaraan sa klase (ibig sabihin, hindi talaga namin ipinangako ang
API na lampas sa pamamaraang iyon).

Sa katunayan, kahit sa loob, hindi kami direktang umuulit, halos palaging pinipilit
ang Hy tree sa pamamagitan ng sumulat ng libro, at madalas itong gawin sa mga sub-element ng isang expression
na kami ay may. Nasa dispatcher na nakabatay sa Uri ang tamang pagpapadala ng mga sub-element.

Ang lahat ng mga pamamaraan na paunang bumubuo ng isang compilation ay minarkahan ng @builds() dekorador. Kaya mo
pumasa sa klase ng modelong Hy na kino-compile nito, o maaari kang gumamit ng string para sa
mga ekspresyon. Aalisin ko ito sa isang segundo.

una Stage Uri-Dispatch
Magsimula tayo sa sumulat ng libro paraan. Ang unang bagay na ginagawa namin ay suriin ang Uri ng bagay
nagtatayo kami. Tumitingin kami upang makita kung mayroon kaming isang paraan na maaaring bumuo ng uri() na kami
mayroon, at ipadala sa paraang makakayanan ito. Kung wala tayong anumang paraan na magagawa
bumuo ng ganoong uri, itinaas namin ang isang panloob Exception.

Halimbawa, kung mayroon tayong a HyString, mayroon kaming halos 1-to-1 na pagmamapa ng Hy AST sa Python
AST. Ang compile_string ang pamamaraan ay tumatagal ng HyString, at nagbabalik ng isang ast.Str() iyan
napuno ng tamang mga line-number at nilalaman.

Macro-Expand
Kung makakakuha tayo ng isang HyExpression, susubukan naming makita kung ito ay isang kilalang Macro, at itulak na magkaroon
pinalawak ito sa pamamagitan ng pagtawag hy.macros.macroexpand, pagkatapos ay itulak ang resulta pabalik sa
HyASTCompiler.compile.

Pangalawa Stage Expression-Dispatch
Ang tanging espesyal na kaso ay ang HyExpression, dahil kailangan nating lumikha ng iba't ibang AST depende
sa espesyal na form na pinag-uusapan. Halimbawa, kapag natamaan natin ang isang (kung totoo totoo mali), Namin
kailangang makabuo ng a ast.Kung, at maayos na i-compile ang mga sub-node. Ito ay kung saan ang @builds()
na may isang String bilang isang argument ay pumapasok.

Para sa compile_expression (na tinutukoy ng isang @builds(HyExpression)) ay magpapadala
batay sa string ng unang argumento. Kung, sa ilang kadahilanan, ang unang argumento ay hindi
isang string, maayos din nitong hahawakan ang kasong iyon (malamang sa pamamagitan ng pagtaas ng isang Exception).

Kung ang String ay hindi kilala ni Hy, ito ay magiging default upang lumikha ng isang ast.Tumawag, na susubukan na
gumawa ng isang runtime na tawag (sa Python, tulad ng foo()).

Mga Isyu Tamaan sa Sawa AST
Ang Python AST ay mahusay; ito ang nagbigay-daan sa amin na magsulat ng napakalakas na proyekto sa ibabaw
Python nang hindi kinakailangang labanan ang Python nang husto. Tulad ng anumang bagay, mayroon kaming makatarungang bahagi
mga isyu, at narito ang isang maikling listahan ng mga pangkaraniwan na maaari mong makita.

Sawa magkakaiba sa pagitan ng Pahayag at expression.

Maaaring hindi ito mukhang isang malaking bagay -- sa katunayan, sa karamihan ng mga programmer ng Python, ito ay gagawin
sa ilang sandali ay naging isang "Well, yeah" na sandali.

Sa Python, gumagawa ng isang bagay tulad ng:

i-print para x in saklaw(10): pumasa, Dahil i-print nagpi-print ng mga expression, at para ay hindi isang
expression, ito ay isang control flow statement. Mga bagay tulad ng 1 + 1 ay Expressions, bilang ay lambda
x: 1 + x, ngunit iba pang mga tampok ng wika, tulad ng if, para, O habang ay mga pahayag.

Dahil wala silang "halaga" sa Python, ginagawa nitong mahirap ang pagtatrabaho sa Hy, dahil gumawa ng isang bagay
gaya ng (i-print (kung totoo totoo mali)) ay hindi lamang karaniwan, ito ay inaasahan.

Bilang resulta, nag-auto-mangle kami ng mga bagay gamit ang a Resulta bagay, kung saan nag-aalok kami ng anuman ast.stmt
na kailangang tumakbo, at isang solong ast.expr na maaaring gamitin upang makuha ang halaga ng anuman
tinakbo lang. Ginagawa ito ni Hy sa pamamagitan ng pagpilit ng pagtatalaga sa mga bagay habang tumatakbo.

Halimbawa, ang Hy:

(i-print (kung totoo true false))

Magiging:

kung totoo:
_mangled_name_here = Totoo
kung hindi:
_mangled_name_here = Mali

i-print ang _mangled_name_dito

OK, medyo kasinungalingan iyon, dahil talagang ginagawa namin ang pahayag na iyon sa:

i-print ang Tama kung Tama kung hindi Mali

Sa pamamagitan ng pagpilit ng mga bagay sa isang ast.expr kung maaari namin, ngunit ang pangkalahatang ideya hold.

Hakbang 4: Sawa byte code Pagbubuhos at Runtime
Pagkatapos naming magkaroon ng Python AST tree na kumpleto, maaari naming subukan at i-compile ito sa Python
bytecode sa pamamagitan ng pagtulak nito eval. Mula rito, wala na tayong kontrol, at
Si Python na ang bahala sa lahat. Ito ang dahilan kung bakit ang mga bagay tulad ng Python tracebacks, pdb at
Gumagana ang mga django app.

Hy Macros
paggamit gensym para Mas ligtas Macros
Kapag nagsusulat ng mga macro, dapat maging maingat upang maiwasan ang pagkuha ng mga panlabas na variable o paggamit
mga variable na pangalan na maaaring sumalungat sa user code.

Gagamit kami ng halimbawang macro nif (Tingnan ang
http://letoverlambda.com/index.cl/guest/chap3.html#sec_5 para sa mas kumpletong paglalarawan.)
nif ay isang halimbawa, tulad ng isang numero if, kung saan batay sa expression, isa sa
3 form ang tinatawag depende sa kung ang expression ay positibo, zero o negatibo.

Ang unang pass ay maaaring katulad ng:

(defmacro nif [expr pos-form na zero-form neg-form]
`(hayaan [[obscure-name ~expr]]
(cond [(pos? obscure-name) ~pos-form]
[(zero? obscure-name) ~zero-form]
[(neg? obscure-name) ~neg-form])))

saan malabo-pangalan ay isang pagtatangka na pumili ng ilang variable na pangalan upang hindi sumalungat sa iba
code. Ngunit siyempre, habang may mabuting layunin, hindi ito garantiya.

Ang pamamaraang gensym ay idinisenyo upang makabuo ng bago, natatanging simbolo para sa gayong okasyon.
Isang mas mahusay na bersyon ng nif maaring maging:

(defmacro nif [expr pos-form na zero-form neg-form]
(hayaan [[g (gensym)]]
`(hayaan [[~g ~expr]]
(cond [(pos? ~g) ~pos-form]
[(zero? ~g) ~zero-form]
[(neg? ~g) ~neg-form]))))

Ito ay isang madaling kaso, dahil mayroon lamang isang simbolo. Ngunit kung may pangangailangan para sa ilan
gensym's mayroong pangalawang macro na may-gensyms na karaniwang lumalawak sa isang serye ng pabayaan
mga pahayag:

(may-gensyms [abc]
...)

lumalawak sa:

(hayaan [[a (gensym)
[b (gensym)
[c (gensym)]]
...)

kaya ang aming muling isinulat nif ay magiging katulad ng:

(defmacro nif [expr pos-form na zero-form neg-form]
(may-gensyms [g]
`(hayaan [[~g ~expr]]
(cond [(pos? ~g) ~pos-form]
[(zero? ~g) ~zero-form]
[(neg? ~g) ~neg-form]))))

Sa wakas, kahit na makakagawa kami ng bagong macro na gumagawa ng lahat ng ito para sa amin. defmacro/g! Dadalhin
lahat ng mga simbolo na nagsisimula sa g! at awtomatikong tumatawag gensym kasama ang natitira sa
simbolo. Kaya ga magiging (gensym "a").

Ang aming huling bersyon ng nif, itinayo sa defmacro/g! nagiging:

(defmacro/g! nif [expr pos-form na zero-form neg-form]
`(hayaan [[~g!res ~expr]]
(cond [(pos? ~g!res) ~pos-form]
[(zero? ~g!res) ~zero-form]
[(neg? ~g!res) ~neg-form]))))

Sinusuri Macro Mga argumento at Pagtaas Exceptions
Hy tagatala Mga Built-In

CONTRIBUTOR MGA MODULO INDEX

Nilalaman:

Anaphoric Macros
Bago sa bersyon 0.9.12.

Ang anaphoric macros module ay gumagawa ng functional programming sa Hy na napakaikli at madaling gawin
basahin.
Ang anaphoric macro ay isang uri ng programming macro na sadyang kumukuha ng ilang anyo
ibinibigay sa macro na maaaring tukuyin ng isang anaphor (isang expression na tumutukoy
sa iba). — Wikipedia (http://en.wikipedia.org/wiki/Anaphoric_macro)

Macros
ap-kung
Paggamit ng: (ap-kung (foo) (i-print ito))

Sinusuri ang unang anyo para sa katotohanan, at itali ito sa it sa parehong totoo at mali
sanga.

ap-bawat isa
Paggamit ng: (ap-bawat [1 2 3 4 5] (i-print ito))

Suriin ang form para sa bawat elemento sa listahan para sa mga side-effects.

ap-bawat-habang
Paggamit ng: (ap-bawat-habang listahan pred katawan)

Suriin ang form para sa bawat elemento kung saan bumalik ang predicate form Totoo.

=> (ap-each-while [1 2 3 4 5 6] (< it 4) (print it))
1
2
3

ap-mapa
Paggamit ng: (ap-map anyo listahan)

Ang anaphoric na anyo ng mapa ay gumagana tulad ng regular na mapa maliban doon sa halip na isang function
bagay na ito ay tumatagal ng isang Hy form. Ang espesyal na pangalan it ay nakatali sa kasalukuyang bagay mula sa
listahan sa pag-ulit.

=> (listahan (ap-map (* ito 2) [1 2 3]))
[2, 4, 6]

ap-map-kailan
Paggamit ng: (ap-map-kailan predfn rep listahan)

Suriin ang isang pagmamapa sa listahan gamit ang isang predicate function upang matukoy kung kailan ilalapat ang
form.

=> (listahan (ap-map-kailan kakaiba? (* ito 2) [1 2 3 4]))
[2, 2, 6, 4]

=> (listahan (ap-map-kailan pa? (* ito 2) [1 2 3 4]))
[1, 4, 3, 8]

ap-filter
Paggamit ng: (ap-filter anyo listahan)

Tulad ng ap-mapa kumuha kami ng isang espesyal na anyo sa halip na isang function upang i-filter ang mga elemento ng
listahan. Ang espesyal na pangalan it ay nakatali sa kasalukuyang elemento sa pag-ulit.

=> (listahan (ap-filter (> (* ito 2) 6) [1 2 3 4 5]))
[4, 5]

ap-tanggihan
Paggamit ng: (ap-reject anyo listahan)

Ginagawa ng function na ito ang kabaligtaran ng ap-filter, tinatanggihan nito ang mga elementong pumasa sa
panaguri . Ang espesyal na pangalan it ay nakatali sa kasalukuyang elemento sa pag-ulit.

=> (listahan (ap-reject (> (* ito 2) 6) [1 2 3 4 5]))
[1, 2, 3]

ap-dotimes
Paggamit (ap-dotimes n katawan)

Sinusuri ng function na ito ang katawan n beses, na may espesyal na variable it nakatali mula sa 0 sa
1-n. Ito ay kapaki-pakinabang para sa mga side effect.

=> (setv n [])
=> (ap-dotimes 3 (.idagdag n ito))
=> n
[0, 1, 2]

ap-una
Paggamit (ap-una predfn listahan)

Ibinabalik ng function na ito ang unang elemento na pumasa sa panaguri o Wala, Sa pamamagitan ng
espesyal na variable it nakatali sa kasalukuyang elemento sa pag-ulit.

=>(ap-first (> ito 5) (saklaw 10))
6

ap-huling
Paggamit (ap-last predfn listahan)

Ibinabalik ng function na ito ang huling elemento na pumasa sa panaguri o Wala, kasama ang espesyal
nagbabago it nakatali sa kasalukuyang elemento sa pag-ulit.

=>(ap-last (> ito 5) (saklaw 10))
9

ap-bawasan
Paggamit (ap-bawasan anyo listahan &opsyonal paunang halaga)

Ibinabalik ng function na ito ang resulta ng paglalapat ng form sa unang 2 elemento sa katawan at
paglalapat ng resulta at ang ika-3 elemento atbp hanggang sa maubos ang listahan. Opsyonal ang isang
maaaring ibigay ang paunang halaga upang mailapat ang function sa paunang halaga at ang
unang elemento sa halip. Inilalantad nito ang elementong inuulit bilang it at ang kasalukuyang
naipon na halaga bilang acc.

=>(ap-reduce (+ it acc) (range 10))
45

loop / umuulit
Bago sa bersyon 0.10.0.

Ang silo / magbalik Ang macro ay nagbibigay sa mga programmer ng isang simpleng paraan upang gamitin ang tail-call optimization (TCO)
sa kanilang Hy code.
Ang tail call ay isang subroutine na tawag na nangyayari sa loob ng isa pang pamamaraan bilang pangwakas nito
aksyon; maaari itong gumawa ng isang return value na pagkatapos ay agad na ibinalik ng pagtawag
pamamaraan. Kung may anumang tawag na ginagawa ng isang subroutine, na maaaring humantong ito sa kalaunan
sa parehong subroutine na tinatawag na muli sa call chain, ay nasa buntot na posisyon,
ang naturang subroutine ay sinasabing tail-recursive, na isang espesyal na kaso ng recursion.
Mahalaga ang mga tail call dahil maipapatupad ang mga ito nang hindi nagdaragdag ng bagong stack
frame sa call stack. Karamihan sa frame ng kasalukuyang pamamaraan ay hindi kailangan
higit pa, at maaari itong mapalitan ng frame ng tail call. Ang programa ay maaaring tumalon
sa tinatawag na subroutine. Ang paggawa ng naturang code sa halip na isang karaniwang pagkakasunud-sunod ng tawag ay
tinatawag na tail call elimination, o tail call optimization. Pinapayagan ang pag-aalis ng tawag sa buntot
mga tawag sa pamamaraan sa posisyon ng buntot upang maipatupad nang kasinghusay ng mga pahayag ng goto,
kaya nagbibigay-daan sa mahusay na structured programming. — Wikipedia (-
http://en.wikipedia.org/wiki/Tail_call)

Macros
silo
silo nagtatatag ng recursion point. Sa silo, magbalik rebinds ang mga variable na itinakda sa
recursion point at nagpapadala ng code execution pabalik sa recursion point na iyon. Kung magbalik ay ginagamit sa
isang posisyon na hindi buntot, ang isang pagbubukod ay itinapon.

Paggamit ng: (loop bindings &magpahinga katawan)

Halimbawa:

(nangangailangan ng hy.contrib.loop)

(defn factorial [n]
(loop [[in] [acc 1]]
(kung (zero? i)
acc
(uulit (dec i) (* acc i)))))

(factorial 1000)

defmulti
Bago sa bersyon 0.10.0.

defmulti hinahayaan kang arity-overload ang isang function sa pamamagitan ng ibinigay na bilang ng mga args at/o kwarg.
Inspirasyon ng mga pananaw ni Clojure defn.

=> (nangangailangan ng hy.contrib.multi)
=> (defmulti fun
... ([a] "a")
... ([ab] "ab")
... ([abc] "abc"))
=> (masaya 1)
"a"
=> (masaya 1 2)
"ab"
=> (masaya 1 2 3)
"abc"

HACKING ON HY

sumali natin Hyve!
Paki-hack si Hy!

Mangyaring sumama sa amin #hy on irc.freenode.net!

Mangyaring pag-usapan ito sa Twitter kasama ang #hy hashtag!

Mangyaring mag-blog tungkol dito!

Mangyaring huwag i-spraypaint ito sa bakod ng iyong kapitbahay (nang hindi nagtatanong ng mabuti)!

Mga hack!
Gawin ito:

1. Gumawa ng sa katunayan kapaligiran:

$ virtualenv venv

at i-activate ito:

$ . venv/bin/activate

o paggamit virtualenvwrapper upang lumikha at pamahalaan ang iyong virtual na kapaligiran:

$ mkvirtualenv hy
$ workon hy

2. Kunin ang source code:

$ git clone https://github.com/hylang/hy.git

o gamitin ang iyong tinidor:

$git clone [protektado ng email]: /hy.git

3. I-install para sa pag-hack:

$ cd hy/
$ pip install -e .

4. Mag-install ng iba pang mga kinakailangan sa pag-develop:

$ pip install -r requirements-dev.txt

5. Gumawa ng mga kahanga-hangang bagay; mapasigaw ang isang tao sa sarap/kasuklam-suklam sa iyong ginawa.

Pagsusulit!
Ang mga pagsubok ay matatagpuan sa mga pagsubok /. Gumagamit kami ilong.

Upang patakbuhin ang mga pagsubok:

$ nosettest

Sumulat ng mga pagsusulit---mahusay ang mga pagsusulit!

Gayundin, mainam na patakbuhin ang mga pagsubok para sa lahat ng platform na sinusuportahan at para sa PEP 8 na sumusunod
code. Magagawa mo ito sa pamamagitan ng pagpapatakbo ng tox:

$ lason

Dokumento!
Ang dokumentasyon ay matatagpuan sa docs /. Gumagamit kami Sphinx.

Upang buuin ang mga doc sa HTML:

$ cd docs
$ gumawa ng html

Sumulat ng mga doc---magaling ang mga doc! Pati itong doc!

Nag-aambag
Ang mga kontribusyon ay malugod na tinatanggap at lubos na pinahahalagahan, bawat maliit na bahagi ay nakakatulong sa paggawa ng higit pang Hy
kasindak-sindak.

Mahusay ang mga kahilingan sa paghila! Mahal namin sila; narito ang isang mabilis na gabay:

· I-fork ang repo at gumawa ng sangay ng paksa para sa isang feature/fix. Iwasang direktang gumawa ng mga pagbabago
sa master branch.

· Ang lahat ng mga papasok na tampok ay dapat na sinamahan ng mga pagsubok.

· Bago ka magsumite ng PR, mangyaring patakbuhin ang mga pagsubok at suriin ang iyong code sa istilo
gabay. Maaari mong gawin ang dalawang bagay na ito nang sabay-sabay:

$ gumawa d

· Gumawa ng mga commit sa mga lohikal na yunit, upang mas madaling subaybayan at i-navigate sa ibang pagkakataon. dati
pagsusumite ng PR, subukang i-squash ang mga commit sa mga pagbabago na madaling balikan
mamaya. Gayundin, siguraduhing hindi ka mag-iiwan ng huwad na whitespace sa mga pagbabago; ito
iniiwasan ang paglikha ng whitespace fix commits mamaya.

· Hanggang sa mag-commit ng mga mensahe, subukang sumunod sa mga sumusunod:

· Subukang manatili sa 50 character na limitasyon para sa unang linya ng Git commit messages.

· Para sa higit pang detalye/paliwanag, sundan ito ng blangkong linya at magpatuloy
inilalarawan nang detalyado ang commit.

· Sa wakas, idagdag ang iyong sarili sa AUTHORS file (bilang isang hiwalay na pangako): karapat-dapat ka :)

· Lahat ng mga papasok na pagbabago ay kailangang ma-ack ng 2 magkaibang miyembro ng pangunahing koponan ng Hylang.
Malinaw na tinatanggap ang karagdagang pagsusuri, ngunit kailangan namin ng hindi bababa sa 2 signoff para sa anuman
baguhin.

· Kung ang isang pangunahing miyembro ay nagpapadala ng isang PR, mangyaring maghanap ng 2 pangunahing miyembro na hindi kasama ang
nagsumite ng PR. Ang ideya dito ay ang isa ay maaaring makipagtulungan sa may-akda ng PR, at isang pangalawang acks
ang buong hanay ng pagbabago.

· Para sa dokumentasyon at iba pang walang kabuluhang pagbabago, mainam kaming magsama pagkatapos ng isang ACK. Mayroon kaming
mababang saklaw, kaya mainam na panatilihing mababa ang hadlang na iyon.

Ubod koponan
Ang pangunahing development team ng Hy ay binubuo ng mga sumusunod na developer:

· Dyulian Danjou

· Morten Linderud

· J Kenneth Hari

· Gergely Nagy

· Tuukka Turto

· Karen Kinakalawang

· Abhishek L

· Christopher Allan Webber

· Konrad Hinsen

· habilin Kahn-Greene

· Paul Tagliamonte

· Nicolas Dandrimont

· Palutang Tolbert

· berker Peksag

· Clinton N. Dreisbach

· siya semaj

Gamitin ang hy online gamit ang mga serbisyo ng onworks.net