hy - Bulutta Çevrimiçi

Program:

ADI

hy - hy Belgeler [image: Hy] [image]

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

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

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

Liste hylang-tartış

IRC #hey Freenode'da

İnşa etmek durum
Travis CI.UNENDENT

Hy, Python'a gömülü harika bir Lisp lehçesidir.

Hy, Lisp kodunu Python Soyut Sözdizimi Ağacına dönüştürdüğünden,
Python'un tüm güzel dünyası, Lisp biçiminde parmaklarınızın ucunda!

İçindekiler:

HIZLI BAŞLANGIÇ

[image: Karen Rustard'ın Sarılmaları] [image]

(Sarılmalar için Karen Rustad'a teşekkürler!)

NASIL TO GET HY GERÇEK HIZLI:

1. Oluşturmak Sanal Python çevre.

2. Sanal Python Ortamınızı etkinleştirin.

3. Kurmak hy itibaren PyPI ile bip kurmak hy.

4. Şununla bir REPL başlatın: hy.

5. REPL'ye bir şeyler yazın:

=> ("Hy!" yazdırın)
Hy!
=> (defn salutationsnm [isim] (yazdır (+ "Hy " isim "!")))
=> (salutationsnm "Adınız")
Merhaba Adınız!

vb

6. İşiniz bittiğinde CTRL-D'ye basın.

OMG! İşte bu inanılmaz! I istemek için yazmak a Hy programı.

7. Seçkin bir programlama düzenleyicisi açın ve şunu yazın:

(print "Python sözdiziminde kod yazacaktım ama sonra Hy aldım.")

8. Farklı kaydet harika.hy.

9. Ve ilk Hy programınızı çalıştırın:

hey harika. hy

10
Hiperventilasyon yapmamak için derin bir nefes alın.

11
Kötü bir şekilde gülümseyin ve hydeaway'inize gizlice gidin ve ağza alınmayacak şeyler yapın.

TUTORIAL

Hy eğitimine hoş geldiniz!

Özetle, Hy bir Lisp lehçesidir, ancak yapısını Python'a çeviren bir dildir...
kelimenin tam anlamıyla Python'un soyut sözdizimi ağacına bir dönüşüm! (Ya da daha kaba koymak için
terimler, Hy bir Python'da peltek çubuktur!)

Bu oldukça havalı çünkü Hy'ın birkaç şey olduğu anlamına geliyor:

· Çok Pythonic hissettiren bir Lisp

· Lisperler için, Lisp'in çılgın güçlerini kullanmanın harika bir yolu, ancak Python'un geniş dünyasında
kütüphaneler (neden evet, artık Lisp'te bir Django uygulaması yazabilirsiniz!)

· Pythonista'lar için, Lisp'i Python'un rahatlığında keşfetmeye başlamanın harika bir yolu!

· Herkes için: Bir sürü güzel fikir içeren hoş bir dil!

Basic intro için yanlış telaffuz için Pythonistalar
Tamam, belki daha önce hiç Lisp kullanmadınız ama Python kullandınız!

Hy'da bir "merhaba dünya" programı aslında çok basittir. Hadi deneyelim:

("merhaba dünya" yazdırın)

Görmek? Kolay! Tahmin edebileceğiniz gibi, bu aşağıdakilerin Python sürümüyle aynıdır:

"merhaba dünya" yazdır

Bazı süper basit matematik eklemek için şunları yapabiliriz:

(+1)

Hangisi 4 döndürür ve şuna eşdeğer olur:

1 + 3

Fark edeceğiniz şey, listedeki ilk öğenin çağrılan fonksiyon olduğu ve
argümanların geri kalanı iletilen argümanlardır. Aslında, Hy'da (çoğunda olduğu gibi)
Lisps) artı operatörüne birden fazla argüman gönderebiliriz:

(+ 1 3 55)

Hangi 59 döndürür.

Belki Lisp'i daha önce duymuşsunuzdur ama hakkında fazla bir şey bilmiyorsunuzdur. Lisp senin kadar zor değil
düşünebilir ve Hy Python'dan miras alır, bu nedenle Hy, Lisp'i öğrenmeye başlamak için harika bir yoldur.
Lisp hakkında bariz olan en önemli şey, çok fazla parantez olması. Bu olabilir
İlk başta kafa karıştırıcı görünebilir, ancak o kadar da zor değil. Bazı basit matematiğe bakalım
Hy yorumlayıcısına girebileceğimiz bir dizi parantez içine alınmış:

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

Bu 38 döndürür. Ama neden? Eh, eşdeğer ifadeye bakabiliriz
piton:

sonuç = ((1 + 3 + 88) / 2) - 8

Yukarıdakilerin python'da nasıl çalıştığını anlamaya çalışacak olsaydınız, elbette
her bir iç parantezi çözerek sonuçları anlayın. Bu aynı temel fikir
Merhaba. Bu alıştırmayı önce Python'da deneyelim:

sonuç = ((1 + 3 + 88) / 2) - 8
# basitleştirilmiş...
sonuç = (92 / 2) - 8
# basitleştirilmiş...
sonuç = 46 - 8
# basitleştirilmiş...
sonuç = 38

Şimdi aynı şeyi Hy'da deneyelim:

(setv sonucu (- (/ (+ 1 3 88) 2) 8))
; basitleştirilmiş...
(setv sonucu (- (/ 92 2) 8))
; basitleştirilmiş...
(setv sonucu (- 46 8)
; basitleştirilmiş...
(setv sonucu 38)

Muhtemelen tahmin ettiğiniz gibi, bu son ifade ile setv değişkeni atamak anlamına gelir
38'e "sonuç".

Görmek? Çok zor değil!

Bu, Lisp'in temel önermesidir. Lisp, "liste işleme" anlamına gelir; bu demektir ki
programın yapısı aslında listelerin listeleridir. (Python'a aşina iseniz
listeler, yukarıdakiyle aynı yapının tamamını hayal edin, ancak bunun yerine köşeli parantez ile, herhangi bir
yukarıdaki yapıyı hem program hem de veri yapısı olarak görebileceksiniz.) Bu
daha fazla örnekle anlaşılması daha kolay, o halde basit bir Python programı yazalım, test edelim,
ve ardından eşdeğer Hy programını gösterin:

def basit_konuşma():
print "Merhaba! Seni tanımak istiyorum. Bana kendinden bahset!"
isim = raw_input("Adın ne? ")
yaş = raw_input("Yaşınız kaç? ")
"Merhaba" + isim + "yazdır! Görüyorum ki " + yaş + " yaşındasın."

basit_konuşma()

Bu programı çalıştırırsak, şöyle olabilir:

Merhaba! Seni tanımak istiyorum. Bana kendinden bahset!
Adın ne? Gary
Yaşınız nedir? 38
Merhaba Gary! 38 yaşında olduğunu görüyorum.

Şimdi eşdeğer Hy programına bakalım:

(defn basit konuşma []
("Merhaba! Seni tanımak istiyorum. Bana kendinden bahset!" yaz)
(setv adı (ham-giriş "Adın ne?"))
(setv age (ham girdi "Yaşınız nedir?"))
(print (+ "Merhaba " isim "! Görüyorum ki "
yaş " yaşında.")))

(basit konuşma)

Yukarıdaki programa bakarsanız, hatırladığınız sürece her birinin ilk elemanı
programın listesi çağrılan fonksiyondur (veya makro... bunlara daha sonra geleceğiz)
ve geri kalanı argümanlar, tüm bunların ne anlama geldiğini anlamak oldukça kolay.
(Muhtemelen sizin de tahmin ettiğiniz gibi, tanım yöntemleri tanımlamanın Hy yöntemidir.)

Yine de, birçok insan ilk başta bunu kafa karıştırıcı buluyor çünkü çok fazla parantez var,
ancak bunu kolaylaştıracak pek çok şey var: girintiyi güzel tutun ve
parantez eşleştirmeli bir düzenleyici kullanın (bu, her birinin ne olduğunu anlamanıza yardımcı olur)
parantez çiftleri ile) ve işler rahat hissetmeye başlayacaktır.

Aslında çok basit bir veri olan bir kod yapısına sahip olmanın bazı avantajları vardır.
Lisp'in çekirdeği olarak yapı dayanmaktadır. Birincisi, programlarınızın
ayrıştırılması kolay ve programın tüm gerçek yapısının çok açık bir şekilde ortaya konması
sana. (Gördüğünüz yapının Python'a dönüştürüldüğü yerde fazladan bir adım var.
kendi temsilleri ... Common Lisp veya Emacs Lisp gibi "daha saf" Lisps'te, veriler
kodda gördüğünüz yapı ve yürütülen veri yapısı çok daha fazla
Kelimenin tam anlamıyla yakın.)

Bunun bir başka anlamı da makrolardır: eğer bir programın yapısı basit bir veri ise
yapı, bu çok kolay kod yazabilen kod yazabileceğiniz anlamına gelir, yani
tamamen yeni dil özelliklerini uygulamak çok hızlı olabilir. Hy'dan önce, bu değildi
Python programcıları için çok mümkün ... şimdi siz de inanılmaz makrolardan yararlanabilirsiniz
güç (sadece onları ileriye doğru hedeflememeye dikkat edin)!

Hy is a Lisp aromalı Python
Hy, Python'un kendi soyut sözdizimi ağacına dönüştürür, böylece yakında hepsini bulmaya başlayacaksınız.
python'un tanıdık gücü parmaklarınızın ucunda.

Hy'da Python'un veri türlerine ve standart kitaplığına tam erişiminiz vardır. deneyelim
hy tercümanında bununla:

=> [1 2 3]
[1, 2, 3]
=> {"köpek" "havlama"
... "kedi" "miyav"}
...
{'köpek': 'havlama', 'kedi': 'miyav'}
=> (, 1 2 3)
(1, 2, 3)

Diğer Lisps'lere aşina iseniz, Hy'ın Common'ı desteklediğini merak edebilirsiniz.
Lisp alıntı yöntemi:

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

Ayrıca tüm yerleşik türlerin Nice yöntemlerine de erişebilirsiniz:

=> (.şerit " fooooo ")
"foooooo"

Bu nedir? Evet gerçekten, bu tam olarak aynı:

" fooooo ".strip()

Bu doğru --- nokta notasyonu ile Lisp! Bu dizgeyi bir değişken olarak atamışsak,
ayrıca şunları da yapabilir:

(bu dizeyi ayarla " fooooo ")
(bu-dize.şerit)

Koşullar ne olacak?:

(eğer (bir şey dene)
("bu doğruysa" yazdırın)
("bu yanlışsa" yazdırın)

Yukarıda anlatabileceğiniz gibi, ilk argüman if bir doğruluk testidir, ikinci argüman ise
gövde doğruysa ve üçüncü argüman (isteğe bağlı!) ise yanlışsa (örn. başka).

Daha karmaşık koşul cümleleri yapmanız gerekiyorsa, sahip olmadığınızı göreceksiniz. elif
Hy'da mevcuttur. Bunun yerine, denilen bir şey kullanmalısın cond. Python'da yapabilirsin
gibi bir şey:

bazıvar = 33
eğer bir değer > 50 ise:
print "Bu değişken çok büyük!"
elif bazıvar < 10:
print "Bu değişken çok küçük!"
Başka:
print "Bu değişken tam olarak doğru!"

Hy'da şunları yapardınız:

(koşul
[(> bazıvar 50)
("Bu değişken çok büyük!" yazdırın)]
[(< bazıvar 10)
("Bu değişken çok küçük!" yazdırın)]
[NS
(print "Bu değişken haklıdır!")])

farkedeceğin şey şu cond yürütülen bazı ifadeler arasında geçiş yapar ve
koşullu olarak doğru veya yanlışlık için kontrol edildi ve ardından dönerse yürütülecek bir miktar kod
doğru olduğu ortaya çıktı. Ayrıca şunu da fark edeceksiniz: başka sonunda basitçe uygulanır
kontrol etmek gerçek -- o yüzden gerçek her zaman doğru olacak, bu yüzden bu kadar ileri gidersek,
her zaman bunu çalıştırın!

Aşağıdaki gibi bir kodunuz varsa, yukarıda fark edebilirsiniz:

(eğer bir koşul
(vücut-eğer-doğruysa)
(eğer yanlışsa-vücut))

Fakat bekle! Aşağıdakilerden birinin gövdesinde birden fazla ifade yürütmek isterseniz ne olur?
bunlar?

Aşağıdakileri yapabilirsiniz:

(eğer (bir şey dene)
(yapmak
("bu doğruysa" yazdırın)
(yazdır "ve neden olmasın, ne kadar doğru olduğu hakkında konuşmaya devam edelim!))
("bu hala sadece yanlış") yazdırın

kullandığımızı görebilirsiniz do birden çok ifadeyi sarmak için. diğerlerine aşina iseniz
Lisps, bu eşdeğerdir tahmin Başka yerde.

Yorumlar noktalı virgülle başlar:

("bu çalışacak" yazdırın)
; ("ama bu olmayacak" yazdırın)
(+ 1 2 3) ; eklemeyi gerçekleştireceğiz, ancak bu yorumu değil!

Döngü zor değil ama bir tür özel yapısı var. Python'da şunları yapabiliriz:

ben için menzil(10):
print "'i' şimdi " + str(i) konumunda

Hy'daki eşdeğeri şöyle olacaktır:

([i (aralık 10) için]
(print (+ "'i' şimdi " (str i)))

Ayrıca çeşitli Python kitaplıklarını içe aktarabilir ve bunlardan yararlanabilirsiniz. Örneğin:

(ithalat işletim sistemi)

(if (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/anotherdir")
("Hey, o yol orada değil!" yazdırın)

Python'un bağlam yöneticileri (ile ifadeler) şu şekilde kullanılır:

([[f ("/tmp/data.in" dosyasını açın) ile]]]
(yazdır (.oku f)))

bu şuna eşdeğerdir:

open("/tmp/data.in") ile f olarak:
f.read()'i yazdır

Ve evet, Liste kavrayışlarımız var! Python'da şunları yapabilirsiniz:

Odds_squared = [
güç(sayı, 2)
num için menzil(100)
eğer sayı % 2 == 1]

Hy'da şunları yapabilirsiniz:

(setv oran-kare
(liste-comp
(güç sayısı 2)
(sayı (aralık 100))
(= (% sayı 2) 1)))

; Ve bir Clojure sayfasından utanmadan çalınan bir örnek:
; Bir Satranç Tahtasının tüm bloklarını listeleyelim:

(liste-comp
(, xy)
(x (aralık 8)
y "ABCDEFGH"))

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

Python, çeşitli süslü argümanları ve anahtar kelime argümanlarını destekler. Python'da olabiliriz
görmek:

>>> def isteğe bağlı_arg(kon1, konum2, anahtar kelime1=Yok, anahtar kelime2=42):
... dönüş [pos1, pos2, anahtar kelime1, anahtar kelime2]
...
>>> isteğe bağlı_arg(1, 2)
[1, 2, Yok, 42]
>>> isteğe bağlı_arg(1, 2, 3, 4)
[1, 2, 3, 4]
>>> isteğe bağlı_arg(anahtar kelime1=1, konum2=2, konum1=3, anahtar kelime2=4)
[3, 2, 1, 4]

Hy'da da aynı şey:

=> (defn isteğe bağlı-arg [konum1 konum2 & isteğe bağlı anahtar kelime1 [anahtarkelime2 42]]
... [poz1 poz2 anahtar kelime1 anahtar kelime2])
=> (isteğe bağlı-arg 1 2)
[1 2 Yok 42]
=> (isteğe bağlı-arg 1 2 3 4)
[1 2 3 4]

0.10.1'den sonraki bir Hy sürümünü kullanıyorsanız (örneğin, git master), ayrıca hoş bir yeni
anahtar kelime bağımsız değişken sözdizimi:

=> (isteğe bağlı-arg :keyword1 1
... :konum2 2
... :konum1 3
... :anahtar kelime2 4)
[3, 2, 1, 4]

Aksi takdirde, her zaman kullanabilirsiniz uygulamak. Ama ne uygulamak?

geçmeye aşina mısın *arglar ve ** kwargs Python'da mı?:

>>> argümanlar = [1 2]
>>> kwargs = {"anahtar kelime2": 3
... "anahtar kelime1": 4}
>>> isteğe bağlı_arg(*args, **kwargs)

Bunu ile çoğaltabiliriz uygulamak:

=> (ayar değişkenleri [1 2])
=> (setv kwargs {"anahtar kelime2" 3
... "anahtar kelime1" 4})
=> (isteğe bağlı bağımsız değişken kwargs uygulayın)
[1, 2, 4, 3]

Ayrıca şuna benzeyen bir sözlük stili anahtar kelime argümanları yapısı vardır:

(defn başka bir tarz [&key {"key1" "val1" "key2" "val2"}]
[anahtar1 tuşu2])

Buradaki fark, bir sözlük olduğu için herhangi bir spesifik bilgiye güvenemezsiniz.
argümanlara göre sıralayın.

Hy ayrıca destekler *arglar ve ** kwargs. Python'da:

def bazı_func(foo, bar, *args, **kwargs):
pprint'i içe aktar
pprint.pprint((foo, bar, argümanlar, kwargs))

Hy eşdeğeri:

(defn bazı işlevler [foo bar &rest args &kwargs kwargs]
(pprint'i içe aktar)
(pprint.pprint (, foo bar kwargs argümanları)))

Son olarak, elbette derslere ihtiyacımız var! Python'da şöyle bir sınıfımız olabilir:

sınıf FooBar(nesne):
"" "
Yine Bir Örnek Sınıf
"" "
tanım __init__(kendi, x):
öz.x = x

def get_x(kendi):
"" "
x kopyamızı iade et
"" "
self.x'i döndür

Hy'da:

(defclass FooBar [nesne]
"Yine Bir Örnek Sınıf"
[[--içinde--
(fn [kendi x]
(setv self.xx)
; Şu anda --init-- için gerekli çünkü __init__ Yok'a ihtiyaç duyuyor
; İnşallah bu gider :)
Hiçbiri)]

[get-x
(fn [öz]
"x kopyamızı iade et"
öz.x)]])

Ayrıca sınıf düzeyinde nitelikler de yapabilirsiniz. Python'da:

sınıf Müşteri(modeller.Model):
isim = modeller.CharField(maks_uzunluk=255)
adres = modeller.TextField()
notlar = modeller.TextField()

Hy'da:

(defclass Müşteri [modelleri.Model]
[[isim (models.CharField :maks-uzunluk 255})]
[adres (models.TextField)]
[notlar (models.TextField)]])

Hy <-> Python Birlikte çalışma
Hy'yi içe aktararak, Hy'yi doğrudan Python'dan kullanabilirsiniz!

Aşağıdakileri kaydederseniz selamlar.hy:

(defn greet [isim] ("hy'den merhaba" adını yazdırın))

Ardından, modülü içe aktarmadan önce hy'yi içe aktararak doğrudan python'dan kullanabilirsiniz. İçinde
Piton:

ithal hy
selamları içe aktar

selamlar.greet("Foo")

Ayrıca python'da (hatta bir sınıf!) bir işlev bildirebilir ve Hy'da kullanabilirsiniz!

Aşağıdakileri kaydederseniz selamlar.py Python'da:

kesinlikle selam(isim):
print("merhaba, %s" % (isim))

Hy'da kullanabilirsiniz:

(ithalat selamları)
(.selam selamlar "foo")

Anahtar kelime bağımsız değişkenlerini kullanmak için şunları kullanabilirsiniz: selamlar.py:

def selamlama(isim, başlık="Efendim"):
print("Selamlar, %s %s" % (başlık,isim))

(ithalat selamları)
(.selam selamlar "Foo")
(.selam selamlar "Foo" "Darth")
(uygulayın (. selamlar selamlar) ["Foo"] {"title" "Lord"})

Hangi çıktı:

Selamlar, Bay Foo

Selamlar, Darth Foo

Selamlar, Lord Foo

Protipler!
Hy ayrıca "diş açma makrosu" olarak bilinen bir şeye sahiptir, bu gerçekten temiz bir özelliktir.
Clojure'un. "İş parçacığı makrosu" (olarak yazılır ->) derin yuvalamayı önlemek için kullanılır
ifade.

İş parçacığı makrosu, her ifadeyi bir sonraki ifadenin ilk argümanına ekler
bir yer.

Gelelim klasiği:

(döngü (yazdır (değerlendirme (okuma))))

Böyle yazmak yerine şöyle yazabiliriz:

(-> (oku) (değerlendir) (yazdır) (döngü))

Şimdi, kullanarak piton-sh, iş parçacığı makrosunun nasıl olduğunu gösterebiliriz (python-sh'ın kurulumu nedeniyle)
boru gibi kullanılabilir:

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

Hangi, elbette, genişler:

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

Çok daha okunaklı, değil mi? İş parçacığı makrosunu kullanın!

HY STİL GUIDE

"Biliyorsunuz Bakan, birçok konuda Dumbledore'a katılmıyorum...
tarzı var…” — Phineas Nigellus Black, Harry Çömlekçi ve the Sipariş Numarası of the anka kuşu

Hy stil kılavuzu, Hyve için bir dizi temel kural olmayı amaçlamaktadır (evet, Hy topluluğu
deyimsel Hy kodu yazmak için her şeye Hy eklemekten gurur duyar. Hy çok şey türetir
Clojure & Common Lisp'ten, Python birlikte çalışabilirliğini her zaman korurken.

Başlangıç
The Tao of Hy
Ummon baş keşişe sordu, "Hangi sutra üzerine ders veriyorsun?"
"Nirvana Sutrası."
"Nirvana Sutra'nın Dört Erdem'i vardır, değil mi?"
"O var."
Ummon bir fincan alarak, "Bunun kaç erdemi var?" diye sordu.
"Hiç," dedi keşiş.
"Ama eski insanlar öyle olduğunu söylediler, değil mi?" dedi Ummon.
"Söyledikleri hakkında ne düşünüyorsun?"
Ummon bardağı vurdu ve "Anladın mı?" diye sordu.
"Hayır," dedi keşiş.
"Öyleyse," dedi Ummon, "sutra derslerine devam etsen iyi olur."
— (koan) makrosu

Aşağıdakiler, yapım aşamasına giren tasarım kararlarının kısa bir listesini göstermektedir.
Hy.

· Lisp gibi görünün; Onunla DTRT (örn. tireler alt çizgilere, kulaklıklar
tümü büyük harf).

· Biz hala Python'uz. Dahililerin çoğu 1: ​​1'i Python dahililerine çevirir.

· Her yerde Unicode kullanın.

· Mümkün olduğunda Python 2'deki kötü kararları düzeltin (bkz. gerçek_bölüm).

· Şüphe duyduğunuzda Python'a başvurun.

· Hala emin değilseniz, Clojure'a başvurun.

· Daha da emin değilseniz, Common Lisp'e başvurun.

· Clojure olmadığımızı unutmayın. Biz Common Lisp değiliz. Biz Homoiconic Python'uz,
mantıklı olan ekstra bitler.

Düzen & girinti
· Sondaki boşluklardan kaçının. Onlar berbat!

· Girinti, girintiyi eşleştirmek dışında, 2 boşluk olacaktır (sabit sekmeler yok).
önceki satır.

;; İyi (ve tercih edilen)
(tanım fib [n]
(eğer (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2))))))

;; hala tamam
(tanım fib [n]
(if (<= n 2) n (+ (fib (- n 1)) (fib (- n 2)))))

;; hala tamam
(tanım fib [n]
(eğer (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2))))))

;; histerik olarak gülünç
(tanım fib [n]
(eğer (<= n 2)
n ;; evet, boşluk tuşuna rastgele basmayı seviyorum
(+ (fib (- n 1)) (fib (- n 2))))))

· Parantezler asla kendi çizgisinde yalnız, üzgün ve yalnız kalmak.

;; İyi (ve tercih edilen)
(tanım fib [n]
(eğer (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2))))))

;; histerik olarak gülünç
(tanım fib [n]
(eğer (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))
)
) ; GAH, ATEŞLE YAKIN

· Dikey olarak hizala izin blokları.

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

· Satır içi yorumlar, kodun sonundan iki boşluk olacaktır; her zaman sahip olmalılar
yorum karakteri ile yorumun başlangıcı arasındaki boşluk. Ayrıca, yapmamaya çalışın
bariz yorum yapın.

;; İyi
(setv ind (ara x)) ; indeksleme 0'dan başlar

;; Tarz uyumlu ama sadece bariz olanı belirtiyor
(setv ind (ara x)) ; indeksi x-1 olarak ayarlar

;; Kötü
(setv ind (dec x));eğlence için kelimeleri yazmak

kodlama stil
· Bir kongre olarak, kullanmamaya çalışın def global değişkenler dışındaki herhangi bir şey için; kullanmak setv
iç işlevler, döngüler vb.

;; İyi (ve tercih edilen)
(def *sınır* 400000)

(defn fibs [ab]
(doğru iken
(verim a)
(setv (, ab) (, b (+ ab)))))

;; Kötü (ve tercih edilmez)
(defn fibs [ab]
(doğru iken
(verim a)
(def (, ab) (, b (+ ab)))))

· Vektör sözdiziminin amaçlandığı yerlerde s-ifadesi sözdizimini kullanmayın. Örneğin, gerçek
bu iki örnekten ilkinin işe yaraması, derleyicinin aşırı derecede olmamasındandır.
sıkı. Gerçekte, bunun gibi yerlerde doğru sözdizimi ikincisidir.

;; Kötü (ve kötü)
(defn foo (x) (x yazdır))
(foto 1)

;; İyi (ve tercih edilen)
(defn foo [x] (x yazdır))
(foto 1)

· Derin bir şekilde iç içe geçmiş durumlarla karşılaştığınızda, diş açma makrosunu veya diş açma kuyruk makrolarını kullanın.
s-ifadeleri. Ancak bunları kullanırken dikkatli olun. Netlik olduğunda bunları kullanın ve
okunabilirlik artar; dolambaçlı, anlaşılması zor ifadeler oluşturmayın.

;; Tercihli
(def *isimler*
([f ("names.txt" dosyasını açın) ile]]
(-> (.read f) (.strip) (.replace "\"" "") (.split ",") (sıralanmış))))

;; Çok iyi değil
(def *isimler*
([f ("names.txt" dosyasını açın) ile]]
(sıralı (.split "," (.replace "\"" "" (.strip (.read f))))))

;; Muhtemelen iyi bir fikir değil
(defn kare? [x]
(->> 2 (pow (int (sqrt x))) (= x)))

· Nesne yönteminin doğrudan çağrılması yerine Clojure tarzı nokta gösterimi tercih edilir,
her ikisi de desteklenmeye devam edecek olsa da.

;; İyi
([fd ile (açık "/ Etc / passwd")]
(yazdır (.readlines fd)))

;; Çok iyi değil
([fd ile (açık "/ Etc / passwd")]
(yazdır (fd.readlines)))

Sonuç
"Moda soluyor, stil sonsuz" -Yves Saint Laurent

Bu kılavuz yalnızca bir dizi topluluk yönergesidir ve açıkçası topluluk yönergeleri
aktif bir topluluk olmadan mantıklı değil. Katkılara açığız. #hy in'de bize katılın
freenode, onun hakkında blog yaz, tweet at ve en önemlisi Hy ile iyi eğlenceler.

Teşekkür
· Bu kılavuzdan büyük ölçüde ilham alınmıştır. @paultag blog yazısı Hy Hayatta kalma Başlangıç Kılavuzu

· Clojure stil Başlangıç Kılavuzu

DOKÜMANTASYON INDEX

İçindekiler:

Komuta çizgi arayüzey
hy
Komuta çizgi Opsiyonlar
-c
Hy kodunu şurada yürütün: komuta.

$ hy -c "(yazdır (+ 2 2))"
4

-i
Hy kodunu şurada yürütün: komuta, ardından REPL'de kalın.

-m
Hy kodunu şurada yürütün: modül, dahil olmak üzere tanımla tanımlıysa.

The -m bayrak, seçenekler listesini sonlandırır, böylece sonraki tüm argümanlar modül isim
modülüne geçirilir sys.argv.

0.10.2 sürümünde yeni.

--casus Yürütmeden önce eşdeğer Python kodunu yazdırın. Örneğin:

=> (defn salutationsnm [isim] (yazdır (+ "Hy " isim "!")))
def selamationsnm(isim):
return print(((u'Hy ' + isim) + u'!'))
=> (salutationsnm "Adınız")
selamlarnm(u'Adınız')
Merhaba Adınız!
=>

0.9.11 sürümünde yeni.

--show-geri izlemeler
Hy istisnaları için genişletilmiş geri izlemeler yazdırın.

0.9.12 sürümünde yeni.

-v Hy sürüm numarasını yazdırın ve çıkın.

hc
Komuta çizgi Opsiyonlar
dosya[, dosyaN]
Hy kodunu Python bayt koduna derleyin. Örneğin, aşağıdaki kodu kaydedin
Hyname.hy:

(defn hy-hy [isim]
(yazdır (+ "Merhaba " isim "!")))

(hy-hy "Afroman")

O zaman koş:

$ Hyc Hyname.hy
$ piton hyname.pyc
Merhaba Afroman!

hy2py
0.10.1 sürümünde yeni.

Komuta çizgi Opsiyonlar
-s

--kaynaklı
Ayrıştırılan kaynak yapısını göster.

-a

--ast ile
Oluşturulan AST'yi gösterin.

-Örneğin

--python olmadan
AST'den oluşturulan Python kodunu gösterme.

Hy ( dil)
UYARI:
Bu eksik; lütfen dokümantasyon çalışmasına katkıda bulunmayı düşünün.

teori of Hy
Hy, her şeyden önce Python ile her iki yönde de %100 uyumluluğu korur
kendisi. Tüm Hy kodu birkaç basit kuralı takip eder. Bunu ezberleyin, çünkü içeri girecek
kullanışlı.

Bu kurallar, Hy kodunun deyimsel ve her iki dilde de arayüzlenebilir olmasını sağlamaya yardımcı olur.

· Kulaklıklardaki semboller, o dizenin büyük harfli versiyonuna çevrilecektir. İçin
örnek, foo Olacak FOO.

· UTF-8 varlıkları kullanılarak kodlanacak punycode ve ön eki ile hy_. Örneğin, ⚘
Olacak hy_w7h, ♥ Olacak hy_g6h, ve ben♥u Olacak hy_iu_t0x.

· Kısa çizgi içeren semboller alt çizgi ile değiştirilecektir. Örneğin,
render şablonu Olacak render_template. Bu, kısa çizgili sembollerin
alt çizgi eşdeğerlerini gölgeleyin ve bunun tersi de geçerlidir.

Yerleşikler
Hy, doğru Python AST'nin oluşturulmasına yardımcı olmak için kullanılan bir dizi özel form içerir.
Aşağıdakiler, bazı durumlarda biraz beklenmedik davranışlara sahip olabilecek "özel" formlardır.
bazı durumlar.

.
0.10.0 sürümünde yeni.

. nesnelere öznitelik erişimi gerçekleştirmek için kullanılır. Hızlı izin vermek için küçük bir DSL kullanır
iç içe geçmiş bir veri yapısındaki niteliklere ve öğelere erişim.

Örneğin,

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

Aşağıya derler:

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

. ilk argümanını derler (örnekte, foo) üzerinde yapılacak nesne olarak
öznitelik dereferans. Erişilecek nitelikler olarak çıplak semboller kullanır (örnekte, bar,
baz, fışkırmak) ve listelerin içeriğini derler (örnekte, [(+ 1 2)]) indeksleme için.
Diğer argümanlar bir derleme hatası verir.

Bilinmeyen niteliklere erişim, bir ÖznitelikHatası. Bilinmeyen anahtarlara erişim, bir
Dizin Hatası (listelerde ve demetlerde) veya Anahtar Hatası (sözlüklerde).

->
-> (Ya da threading makro) ifadelerin iç içe geçmesini önlemek için kullanılır. iş parçacığı makrosu
her ifadeyi bir sonraki ifadenin ilk argüman yerine ekler. Devamındaki
kod bunu gösterir:

=> (defn çıktısı [ab] (ab yazdır))
=> (-> (+ 4 6) (çıkış 5))
10 5

- >>
- >> (Ya da threading kuyruk makro) benzer threading makroama bunun yerine
her ifadeyi bir sonraki ifadenin ilk argümanına ekleyerek, onu şu şekilde ekler:
son argüman. Aşağıdaki kod bunu gösterir:

=> (defn çıktısı [ab] (ab yazdır))
=> (->> (+ 4 6) (çıkış 5))
5 10

uygulamak
uygulamak isteğe bağlı bir argüman listesi ve isteğe bağlı bir kwargs sözlüğü uygulamak için kullanılır
bir işleve.

Kullanımı: (uygulamak fn-adı [arg] [kwargs])

Örnekler:

(defn teşekkürler []
"merhaba")

(thunk uygula)
;=> "merhaba"

(defn toplam satın alma [fiyat tutarı ve isteğe bağlı [ücret 1.05] [kdv 1.1]]
(*fiyat tutarı ücretleri kdv))

(toplam satın alma [10 15] uygulayın)
;=> 173.25

(toplam satın alma [10 15] {"vat" 1.05} uygulayın)
;=> 165.375

(toplam satın alma [] {"fiyat" 10 "tutar" 15 "kdv" 1.05} uygulayın)
;=> 165.375

ve
ve mantıksal ifadelerde kullanılır. En az iki parametre alır. Eğer tüm parametreler
değerlendirmek Gerçek, son parametre döndürülür. Başka bir durumda, ilk yanlış değer
iade edilecek. Örnek kullanım:

=> (ve Doğru Yanlış)
Yanlış

=> (ve Gerçek Doğru)
Gerçek

=> (ve Gerçek 1)
1

=> (ve Doğru [] Yanlış Doğru)
[]

NOT:
ve kısa devre yapar ve ilk yanlış olduğu anda parametreleri değerlendirmeyi durdurur
karşılaştı.

=> (ve False ("merhaba") yazdırın)
Yanlış

ileri sürmek
ileri sürmek program çalışırken koşulları doğrulamak için kullanılır. eğer koşul değilse
tanıştım, bir OnaylamaHatası yükseltildi. ileri sürmek bir veya iki parametre alabilir. İlk
parametre, kontrol edilecek koşuldur ve ikisinden birini değerlendirmelidir. Gerçek or Yanlış.
isteğe bağlı ikinci parametre, onaylama için bir etikettir ve olacak dizedir.
ile yükseltilmiş OnaylamaHatası. Örneğin:

(varsayım (= değişken beklenen değer))

(Yanlış iddia et)
; OnaylamaHatası

(iddia (= 1 2) "biri ikiye eşit olmalıdır")
; AssertionError: bir iki eşit olmalıdır

Doç
Doç bir anahtarı sözlükteki bir değerle ilişkilendirmek veya bir listenin indeksini ayarlamak için kullanılır
bir değere. En az üç parametre alır: veri yapı değiştirilecek, bir anahtar
or indeksVe değer. Üçten fazla parametre kullanılırsa, çiftler halinde ilişkilendirilecektir.

Kullanım örnekleri:

=>([[koleksiyon {}]] olsun
... (doçent koleksiyonu "Köpek" "Kabuk")
... (baskı koleksiyonu))
{u'Köpek': u'Bark'}

=>([[koleksiyon {}]] olsun
... (doçent koleksiyonu "Köpek" "Bark" "Kedi" "Miyav")
... (baskı koleksiyonu))
{u'Kedi': u'Miyav', u'Köpek': u'Bark'}

=>([[koleksiyon [1 2 3 4]]] olsun
... (doçent koleksiyonu 2 Yok)
... (baskı koleksiyonu))
[1, 2, Yok, 4]

NOT:
Doç veri yapısını yerinde değiştirir ve geri döner Hayır.

kırılma
kırılma döngüden çıkmak için kullanılır. Döngüyü hemen sonlandırır. Devamındaki
örneğin sonsuz süre kullanıcı girer girmez sonlandırılan döngü k.

(while True (if (= "k" (ham girdi "? "))
(kırmak)
("Tekrar deneyin") yazdırın)

cond
cond iç içe oluşturmak için kullanılabilir if ifadeler. Aşağıdaki örnek,
makro ve genişlemesi arasındaki ilişki:

(koşul [koşul-1 sonuç-1]
[koşul-2 sonuç-2])

(eğer durum-1 sonuç-1 ise
(eğer durum-2 sonuç-2 ise))

Aşağıda gösterildiği gibi, yalnızca ilk eşleşen sonuç bloğu yürütülür.

=> (defn kontrol değeri [değer]
... (koşul [(< değer 5) (yazdır "değer 5'ten küçüktür")]
... [(= değer 5) ("değer eşittir 5")]
... [(> değer 5) ("değer 5'ten büyük" yazdır)]
... [Doğru (yazdır "değer olmaması gereken bir şeydir")]))

=> (kontrol değeri 6)
değer 5'ten büyük

devam etmek
devam etmek yürütmeyi bir döngünün başlangıcına döndürür. Aşağıdaki örnekte,
(yan etki1) her yineleme için çağrılır. (yan etki2)ancak, yalnızca çağrılır
listedeki diğer tüm değerler.

;; (yan etki1) ve (yan etki2) fonksiyonlarının olduğunu varsayarsak ve
;; koleksiyon, sayısal değerlerin bir listesidir

([x koleksiyonu] için
(yapmak
(yan etki1 x)
(eğer (% x 2)
(devam et))
(yan etki2 x)))

dikte kompozisyonu
dikte kompozisyonu sözlükler oluşturmak için kullanılır. Üç veya dört parametre alır. İlk
iki parametre dönüş değerini (anahtar/değer çifti) kontrol etmek içindir, üçüncüsü ise
bir diziden öğeleri seçmek için kullanılır. Dördüncü ve isteğe bağlı parametre,
koşullu bir ifadeye dayalı olarak dizideki bazı öğeleri filtreleyin.

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

do / tahmin
do ve tahmin argümanlarının her birini değerlendirmek ve sonuncusunu döndürmek için kullanılır. Dönüş
son bağımsız değişken dışındaki her değerden değerler atılır. içinde kullanılabilir lambda or
liste-comp aşağıdaki örneklerden birinde gösterildiği gibi daha karmaşık mantık gerçekleştirmek için.

Bazı örnek kullanım:

=> (eğer doğruysa
... (yap ("Yan etkiler kaya!" yazdır)
... ("Evet, gerçekten!" yazdırın)))
Yan etkiler kaya!
Evet gerçekten!

;; (yan etkinin) her biri için çağırmak istediğimiz bir fonksiyon olduğunu varsayarsak
;; ve listedeki her değer, ancak geri dönüş değeri umurumuzda değil
=> (list-comp (do (yan etki x)
... (eğer (< x 5) (* 2 x)
... (* 4x)))
... (x (aralık 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do 1'den n'ye kadar herhangi bir sayıda argüman kabul edebilir.

def / setv
def ve setv bir değeri, nesneyi veya işlevi bir sembole bağlamak için kullanılır. Örneğin:

=> (tanım adları ["Alice" "Bob" "Charlie"])
=> (isimleri yazdır)
[u'Alice', u'Bob', u'Charlie']

=> (setv sayacı (fn [koleksiyon öğesi] (.count koleksiyon öğesi)))
=> (sayaç [1 2 3 4 5 2 3] 2)
2

Defclass
Yeni sınıflar ile ilan edilir Defclass. İki isteğe bağlı parametre alabilir: bir vektör
olası bir süper sınıf ve yeninin niteliklerini içeren başka bir vektörün tanımlanması
iki öğe vektörü olarak sınıf.

(defclass sınıf adı [süper-sınıf-1 süper-sınıf-2]
[[özellik değeri]])

Aşağıdaki örnekte gösterildiği gibi hem değerler hem de işlevler yeni sınıfa bağlanabilir:

=> (defclass Cat []
... [[yaş Yok]
... [renk "beyaz"]
... [konuş (fn [self] ("Miyav"))]])

=> (def nokta (Kedi))
=> (setv spot.color "Siyah")
'Siyah'
=> (.konuşma noktası)
miyav

tanım / eğlenceyi bozmak
tanım ve eğlenceyi bozmak makrolar fonksiyonları tanımlamak için kullanılır. Üç parametre alırlar: isim
tanımlanacak fonksiyonun bir vektörü parametreler, Ve vücut fonksiyonun:

(defn name [params] gövdesi)

Parametrelerin önünde aşağıdaki anahtar kelimeler olabilir:

&isteğe bağlı
Parametre isteğe bağlıdır. Parametre, iki öğeli bir liste olarak verilebilir;
ilk öğe parametre adıdır ve ikincisi varsayılan değerdir. parametre
tek bir öğe olarak da verilebilir, bu durumda varsayılan değer Hayır.

=> (defn toplam değer [değer &isteğe bağlı [katma değer vergisi 10]]
... (+ (/ (* katma değer-vergi değeri) 100) değer))

=> (toplam değer 100)
110.0

=> (toplam değer 100 1)
101.0

&anahtar

&kwargs
Parametre, 0 veya daha fazla anahtar kelime bağımsız değişkeni içerecektir.

Aşağıdaki kod örnekleri, all anahtar sözcüğünü yazdıracak bir işlevi tanımlar.
argümanlar ve değerleri.

=> (defn print-parameters [&kwargs kwargs]
... ([(, kv için) (.items kwargs)] (kv yazdır)))

=> (print-parameters [] {"parametre-1" 1 "parametre-2" 2} uygula)
parametre-2 2
parametre-1 1

&dinlenmek Parametre, 0 veya daha fazla konumsal argüman içerecektir. Başka pozisyon yok
argümanlar bundan sonra belirtilebilir.

Aşağıdaki kod örneği, 0'dan n'ye sayısal olarak verilebilecek bir işlevi tanımlar.
parametreler. Daha sonra her tek sayıyı toplar ve her çift sayıyı çıkarır.

=> (defn zig-zag-sum [&geri kalan sayılar]
([[tek sayılar (list-comp x [x sayılar] (tek? x))]
[çift sayılar (list-comp x [x sayılar] (çift? x))]]
(- (tek sayıların toplamı) (çift sayıların toplamı))))

=> (zikzak toplamı)
0
=> (zikzak toplamı 3 9 4)
8
=> (zikzak toplamı 1 2 3 4 5 6)
-3

defn-takma ad / defun takma adı
0.10.0 sürümünde yeni.

The defn-takma ad ve defun takma adı makrolar çok benzer tanımfarkıyla,
Tek bir adla bir fonksiyon tanımlamak yerine, bunlar aynı zamanda takma adlar da tanımlayabilir. Diğer
ilk parametre olarak işlev adları için bir sembol listesi almaktansa, defn-takma ad ve
defun takma adı farklı değil tanım ve eğlenceyi bozmak.

=> (defn-alias [ana ad takma adı] []
... ("Merhaba!" yazdırın))
=> (ana isim)
"Merhaba!"
=> (takma ad)
"Merhaba!"

tanımla
0.10.1 sürümünde yeni.

The tanımla makro ile hemen çağrılan bir ana işlevi tanımlar. sys.argv as
bağımsız değişkenler, yalnızca bu dosya bir komut dosyası olarak yürütülüyorsa. Başka bir deyişle, bu:

(defmain [&rest args]
(arglarla bir şeyler yap))

şuna eşdeğerdir:

def ana(*args):
do_something_with(arg)
0 döndür

eğer __name__ == "__main__":
ithalat sistemi
retval = ana(*sys.arg)

isinstance(retval, int) ise:
sys.exit(geri alma)

Yukarıda gördüğünüz gibi, bu fonksiyondan bir tamsayı döndürürseniz, bunun olacağını unutmayın.
betiğiniz için çıkış durumu olarak kullanılır. (Python varsayılan olarak 0 durumundan çıkar, aksi halde
bu da her şeyin yolunda olduğu anlamına gelir!)

(Dan beri (sys.çıkış 0) tamsayı olmayan bir dönüş durumunda açıkça çalıştırılmaz
tanımlakoymak iyi bir fikirdir. (tanımlamak) dosyanızdaki son kod parçası olarak.)

defmakro
defmakro makroları tanımlamak için kullanılır. genel biçimidir (defmakro isim [parametreler]
ifade).

Aşağıdaki örnek, koddaki öğelerin sırasını değiştirmek için kullanılabilecek bir makro tanımlar,
kullanıcının, operatörün arasında olduğu yerde, infix notasyonunda kod yazmasına izin verir.
işlenenler.

=> (defmakro eki [kod]
... (sözde alıntı (
... (alıntıyı kaldır (kod 1))
... (alıntıyı kaldır (kod 0))
... (alıntıyı kaldır (kod 2)))))

=> (ek (1 + 1))
2

defmakro-alias
defmakro-alias birden çok ad (takma ad) olan makroları tanımlamak için kullanılır. genel biçim
is (defmakro-takma ad [isimler] [parametreler] ifade). Aynı ile birden fazla makro oluşturur
parametre listesi ve gövdesi, belirtilen ad listesi altında.

Aşağıdaki örnek, her ikisi de kullanıcının kod yazmasına izin veren iki makroyu tanımlar.
infix notasyonu.

=> (defmacro-alias [infix infi] [kod]
... (sözde alıntı (
... (alıntıyı kaldır (kod 1))
... (alıntıyı kaldır (kod 0))
... (alıntıyı kaldır (kod 2)))))

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

defmakro/g!
0.9.12 sürümünde yeni.

defmakro/g! özel bir versiyonudur defmakro otomatik olarak oluşturmak için kullanılan jimnastik
ile başlayan herhangi bir sembol için g!.

Örneğin, g!a olacaktı (gensim "a").

GDA AYRICA:
Bölüm kullanma-gensym

koruyucu
0.9.12 sürümünde yeni.

koruyucu sözdizimini yeniden yapılandırmanıza veya değiştirmenize olanak tanıyan bir okuyucu makrosu tanımlar.

=> (defreader ^ [ifade] (baskı ifadesi))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Merhaba"
"Merhaba"

GDA AYRICA:
Bölüm Okuyucu Makroları

del
0.9.12 sürümünde yeni.

del geçerli ad alanından bir nesneyi kaldırır.

=> (setv foo 42)
=> (del foo)
=> foo
Geri izleme (en son yapılan arama):
Dosya " ", satır 1, içinde
NameError: 'foo' adı tanımlı değil

del nesneleri eşlemelerden, listelerden ve daha fazlasından da kaldırabilir.

=> (setv testi (liste (aralık 10)))
=> test
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (del (dilim testi 2 4)) ;; 2'den 4'e kadar hariç tutulan öğeleri kaldır
=> test
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "bar"})
=> dik
{"foo": "çubuk"}
=> (del (dic "foo") alın)
=> dik
{}

yapmak
0.10.1 sürümünde yeni.

yapmak bir nesneye yapılan bir dizi yöntem çağrısını basitleştirmek için kullanılır.

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

=> (setv koleksiyonu [])
=> (.append koleksiyonu 1)
=> (.append koleksiyonu 2)
=> (.ters toplama)
=> koleksiyon
[2 1]

değerlendirme
değerlendirme alıntılanan bir ifadeyi değerlendirir ve değeri döndürür.

=> (eval '("Merhaba Dünya") yazdırın)
"Bonjour Monde"

değerlendir ve derle
değerlendirme-ne zaman-derleme
ilk / araba
ilk ve araba bir koleksiyonun ilk öğesine erişmek için kullanılan makrolardır:

=> (ilk (aralık 10))
0

için
için bir liste veya vektördeki her öğe için bir işlev çağırmak için kullanılır. Her birinin sonuçları
arama iptal edilir ve için ifade döner Hayır Bunun yerine. Örnek kod yineleniyor
tekrar Toplamak ve her biri için eleman in Toplamak çağırır yan etki ile çalışmak
eleman argümanı olarak:

;; (yan etki) tek bir parametre alan bir fonksiyon olduğunu varsayarsak
([öğe koleksiyonu] için (yan etki öğesi))

;; için isteğe bağlı bir else bloğu olabilir
([öğe koleksiyonu] için (yan etki öğesi)
(başka (yan etki-2)))

İsteğe bağlı başka blok yalnızca şu durumlarda yürütülür: için döngü normal olarak sona erer. Eğer
ile yürütme durduruldu kırılma, başka blok yürütülmüyor.

=> ([eleman [1 2 3]] için (eğer (< eleman 3)
... (baskı öğesi)
... (kırmak))
... (başka ("döngü tamamlandı") yazdırın))
1
2

=> ([eleman [1 2 3]] için (eğer (< eleman 4)
... (baskı öğesi)
... (kırmak))
... (başka ("döngü tamamlandı") yazdırın))
1
2
3
döngü tamamlandı

gen ifadesi
gen ifadesi jeneratör ifadeleri oluşturmak için kullanılır. İki veya üç parametre alır. bu
ilk parametre, dönüş değerini kontrol eden ifadedir, ikincisi ise kullanılır
Listeden öğeleri seçmek için Üçüncü ve isteğe bağlı parametre, filtrelemek için kullanılabilir
koşullu bir ifadeye dayalı listedeki bazı öğeler. gen ifadesi benzer
liste-compyerine değerleri tek tek değerlendiren bir yinelenebilir döndürmesi dışında
hemen değerlendirir.

=> (def koleksiyonu (aralık 10))
=> (def filtrelendi (genexpr x [x koleksiyonu] (çift? x)))
=> (liste filtrelendi)
[0, 2, 4, 6, 8]

jimnastik
0.9.12 sürümünde yeni.

jimnastik makroların yazılmadan yazılmasına izin veren benzersiz bir sembol oluşturmak için kullanılır.
tesadüfi değişken adı çakışmaları.

=> (gensim)
u':G_1235'

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

GDA AYRICA:
Bölüm kullanma-gensym

almak
almak listelerdeki ve sözlüklerdeki tek öğelere erişmek için kullanılır. almak iki parametre alır:
the veri yapı ve indeks or anahtar öğenin. Daha sonra karşılık gelen geri dönecek
sözlükten veya listeden değer. Örnek kullanım:

=> ([[hayvanlar {"köpek" "havlama" "kedi" "miyav"}]
... [sayılar ["sıfır" "bir" "iki" "üç"]]]
... (yazdır (hayvanları "köpek") al)
... (yazdır (2 sayıları al))
havlama
iki

NOT:
almak var olmayan bir anahtar için bir sözlük sorgulanırsa bir KeyError oluşturur.

NOT:
almak olmayan bir dizin için bir liste veya bir tanımlama grubu sorgulanırsa bir IndexError oluşturur.
sınırlar.

global
global bir sembolü global olarak işaretlemek için kullanılabilir. Bu, programcının bir
küresel bir sembole değer. Global bir sembolün okunması, global anahtar kelime --
sadece atama yapar.

Aşağıdaki örnek, global sembolün nasıl a bir fonksiyonda bir değer atanır ve
daha sonra başka bir işlevde yazdırılır. olmadan global anahtar kelime, ikinci işlev
atmış olurdu İsim Hatası.

(defn set-a [değer]
(küresel a)
(bir değer ayarlayın))

(defn print-a []
(a yazdır)

(set-a 5)
(baskı-a)

if / eğer-değil
0.10.0 sürümünde yeni: if-not

if Çalıştırılacak kodu koşullu olarak seçmek için kullanılır. Bir koşul içermesi gerekir
blok ve koşul bloğu şu şekilde değerlendirilirse yürütülecek blok Gerçek. Opsiyonel olarak,
koşulun değerlendirilmesi durumunda yürütülen bir son blok içerebilir.
Yanlış.

eğer-değil benzerdir, ancak koşul başarısız olduğunda ikinci blok yürütülür.
üçüncü ve son blok, test başarılı olduğunda yürütülür -- if.

Örnek kullanım:

(if (para kaldı mı? hesap)
("Hadi alışverişe gidelim" yazdırın)
("hadi gidelim ve çalışalım") yazdırın)

(eğer-yoksa (para kaldı mı? hesap)
("hadi gidelim ve çalışalım" yazdırın)
("Hadi alışverişe gidelim") yazdırın)

Python doğruluğuna saygı duyulur. Hayır, Yanlış, herhangi bir sayısal türde sıfır, boş bir dizi,
ve boş bir sözlük kabul edilir Yanlış; diğer her şey düşünülür Gerçek.

lisp-eğer / hayat ve lisp-eğer-olmazsa / cansız
0.10.0 sürümünde yeni.

0.10.2 sürümündeki yenilikler: lisp-if-not / lift-not

Daha Lispy tercih edenler için if madde, biz var lisp-eğerya da hayat. Bu bir tek dikkate
Hayır / sıfır yalan olmak! Diğer tüm "yanlış" Python değerleri doğru kabul edilir.
Tersine, biz var lisp-eğer-olmazsa ve cansız paralel olarak if ve eğer-değil hangi tersine döner
mukayese.

=> (lisp-eğer Doğru "doğru" "yanlış")
"doğru"
=> (lisp-if False "doğru" "yanlış")
"doğru"
=> (lisp-if 0 "doğru" "yanlış")
"doğru"
=> (lisp-if nil "true" "false")
"yanlış"
=> (lisp-if Yok "doğru" "yanlış")
"yanlış"
=> (lisp-if-not nil "true" "false")
"doğru"
=> (lisp-if-not Yok "doğru" "yanlış")
"doğru"
=> (lisp-if-not False "true" "false")
"yanlış"

; Eşdeğer ancak daha kısa
=> (lif True "true" "false")
"doğru"
=> (lif nil "doğru" "yanlış")
"yanlış"
=> (lif-not Yok "doğru" "yanlış")
"doğru"

ithalat
ithalat Python'da olduğu gibi modülleri içe aktarmak için kullanılır. Bunun birkaç yolu var ithalat yapabilmek
Kullan

;; Bu modüllerin her birini içe aktarır
;;
;; Piton:
;; ithalat sistemi
;; os.path'i içe aktar
(sys os.path dosyasını içe aktarın)

;; Bir modülden içe aktar
;;
;; Python: os.path'den içe aktarma var, isdir, isfile
(ithalat [os.path [exists isdir isfile]])

;; Takma adla içe aktar
;;
;; Python: sys'yi systest olarak içe aktar
([sys :systest] olarak içe aktar)

;; Farklı türlerden istediğiniz kadar ithalat listeleyebilirsiniz.
([tests.resources [kwtest işlevi-a-dash]] içe aktarın
[os.path [isdir isfile var]]
[sys :sistem olarak])

;; Tüm modül işlevlerini geçerli ad alanına içe aktarın
(ithalat [sys [*]])

lambda / fn
lambda ve fn anonim bir işlevi tanımlamak için kullanılabilir. Parametreler şuna benzer:
tanım: ilk parametre parametrelerin vektörüdür ve geri kalanı
fonksiyonu. lambda yeni bir işlev döndürür. Aşağıdaki örnekte, anonim bir işlev
çıktıyı filtrelemek için tanımlanır ve başka bir işleve iletilir.

=> (def insanlar [{:name "Alice" :yaş 20}
... {:isim "Bob" :yaş 25}
... {:adı "Charlie" :yaş 50}
... {:ad "Dave" :yaş 5}])

=> (defn display-people [kişi filtresi]
... ([kişiler] için (if (filtre kişi) (yazdır (:kişi adı)))))

=> (kişileri göster (fn [kişi] (< (:yaş kişi) 25)))
atış
Dave

Normal fonksiyon tanımlarında olduğu gibi, gövdenin ilk elemanı bir dizge ise,
docstring görevi görür. Bu, sınıf yöntemlerine belge dizileri vermek için kullanışlıdır.

=> (setv kere-üç
... (fn [x]
... "Girdiyi üçle çarpar ve sonucu döndürür."
... (*x3)))

Bu, Python'un yerleşik yazılımı aracılığıyla onaylanabilir. yardım et işlevi:

=> (yardım kere-üç)
Times_XNUMX işleviyle ilgili yardım:

kez_üç(x)
Girdiyi üçle çarpar ve sonucu döndürür
(SON)

son
0.10.2 sürümünde yeni.

son bir koleksiyonun son öğesine erişmek için kullanılabilir:

=> (son [2 4 6])
6

izin
izin sözlüksel olarak kapsamlı değişkenler oluşturmak için kullanılır. başlangıcında oluşturulurlar.
izin form ve formdan sonra yok olur. Aşağıdaki örnek bunu göstermektedir
davranış:

=> ([[x 5]] olsun (x yazdır)
... ([[x 6]] olsun (x yazdır))
... (x yazdır))
5
6
5

The izin makro iki parametre alır: bir vektör tanımlayan değişkenler ve vücut hangi alır
idam edildi. değişkenler her öğenin tek bir değişken veya bir vektör olduğu bir vektördür
değişken bir değer çifti tanımlama. Tek bir değişken olması durumunda, değer atanır
Hayır; aksi takdirde sağlanan değer kullanılır.

=> ([x [y 5]] olsun (xy yazdır))
Yok 5

liste-comp
liste-comp liste anlama işlemlerini gerçekleştirir. İki veya üç parametre alır. İlk
parametre, dönüş değerini kontrol eden ifadedir, ikincisi ise
listeden öğeleri seçin. Üçüncü ve isteğe bağlı parametre, bazılarını filtrelemek için kullanılabilir.
koşullu bir ifadeye dayalı olarak listedeki öğelerin sayısı. Bazı örnekler:

=> (def koleksiyonu (aralık 10))
=> (list-comp x [x koleksiyonu])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

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

değil
değil mantıksal ifadelerde kullanılır. Tek bir parametre alır ve tersine çevrilmiş bir
gerçek değer. Eğer Gerçek parametre olarak verilir, Yanlış iade edilecek ve tam tersi.
Örnek kullanım:

=> (Doğru değil)
Yanlış

=> (Yanlış değil)
Gerçek

=> (Yok değil)
Gerçek

or
or mantıksal ifadelerde kullanılır. En az iki parametre alır. iade edecek
ilk yanlış olmayan parametre. Böyle bir değer yoksa, son parametre döndürülür.

=> (veya Doğru Yanlış)
Gerçek

=> (ve Yanlış Yanlış)
Yanlış

=> (ve Yanlış 1 Doğru Yanlış)
1

NOT:
or kısa devre yapar ve ilk gerçek değer elde edilir edilmez parametreleri değerlendirmeyi durdurur.
karşılaştı.

=> (veya Doğru ("merhaba") yazdırın)
Gerçek

baskı
baskı ekranda çıktı almak için kullanılır. Örnek kullanım:

("Merhaba dünya!" yazdırın)

NOT:
baskı her zaman geri döner Hayır.

sözde
sözde bir formdan alıntı yapmanıza ve aynı zamanda ifadeleri seçici olarak değerlendirmenize olanak tanır.
içindeki ifadeler sözde kullanılarak seçici olarak değerlendirilebilir. tırnağı kapatmak (~.)
değerlendirilen form ayrıca kullanılarak birleştirilebilir tırnak işareti (~@). Quasiquote da olabilir
ters alıntı kullanılarak yazılmıştır (`) sembolü.

;; 'qux' değeri olan bir değişken olsun (bar baz)
`(foo ~qux)
; '(foo (bar baz)) ile eşdeğer
`(foo ~@qux)
; '(foo bar baz)'a eşdeğer

alıntı yapmak
alıntı yapmak kendisine iletilen formu değerlendirmeden döndürür. alıntı yapmak alternatif olarak olabilir
kesme işareti kullanılarak yazılır (') sembolü.

=> (setv x '("Merhaba Dünya") yazdırın)
; x değişkeni ifadeye ayarlandı ve değerlendirilmedi
=> x
('u'Merhaba Dünya'yı yazdırın)
=> (değer x)
Merhaba Dünya

gerektirir
gerektirir belirli bir modülden makroları içe aktarmak için kullanılır. En az bir parametre alır
hangi makroların içe aktarılacağını belirten modül. Birden fazla modül içe aktarılabilir
tek bir gerektirir.

Aşağıdaki örnek, makroları şuradan içe aktaracaktır: modül-1 ve modül-2:

(modül-1 modül-2 gerektirir)

dinlenme / cdr
dinlenme ve cdr ilk öğe olmadan bağımsız değişken olarak iletilen koleksiyonu döndür:

=> (dinlenme (aralık 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]

set-comp
set-comp kümeler oluşturmak için kullanılır. İki veya üç parametre alır. İlk parametre
dönüş değerini kontrol etmek için, ikincisi ise bir öğeden öğeleri seçmek için kullanılır.
sıra. Üçüncü ve isteğe bağlı parametre, içindeki bazı öğeleri filtrelemek için kullanılabilir.
koşullu bir ifadeye dayalı dizi.

=> (ayar verileri [1 2 3 4 5 2 3 4 5 3 4 5])
=> (set-comp x [x veri] (tek? x))
{1, 3, 5}

dilim
dilim bir listenin alt kümesini almak ve ondan yeni bir liste oluşturmak için kullanılabilir. form
dilimlenecek listeyi belirten en az bir parametre alır. İki isteğe bağlı parametre olabilir
alt kümenin başlangıç ​​ve bitiş konumunu vermek için kullanılır. Eğer tedarik edilmezlerse,
varsayılan değeri Hayır yerine kullanılacaktır. Üçüncü isteğe bağlı parametre,
elemanlar arasındaki kontrol adımı.

dilim Python muadili ile aynı kuralları takip eder. Negatif endeksler sayılır
listenin sonundan başlayarak. Bazı örnek kullanım:

=> (def koleksiyonu (aralık 10))

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

=> (dilim koleksiyonu 5)
[5, 6, 7, 8, 9]

=> (dilim toplama 2 8)
[2, 3, 4, 5, 6, 7]

=> (dilim toplama 2 8 2)
[2, 4, 6]

=> (dilim toplama -4 -2)
[6, 7]

atmak / yükseltmek
The atmak or yükseltmek formlar yükseltmek için kullanılabilir Istisna işlem esnasında. Örnek kullanım:

(atmak)
; son istisnayı yeniden oluştur

(IOError atmak)
; Bir IOError atın

(fırlatma (IOError "foobar"))
; Bir IOError("foobar") atın

atmak tek bir argümanı kabul edebilir (bir Istisna sınıf veya örnek) veya argüman yok
sonuncuyu yeniden yükselt Istisna.

denemek
The denemek form başlatmak için kullanılır denemek / yakalamak engellemek. Form aşağıdaki gibi kullanılır:

(denemek
(hataya açık-fonksiyon)
([e ZeroDivisionError]'u yakalayın ("Sıfıra bölme" yazdırın)
(başka ("hata yok") yazdırın)
(son olarak ("hepsi bitti") yazdırın))

denemek en az bir tane içermelidir yakalamak blok ve isteğe bağlı olarak bir başka or nihayet
engellemek. Yürütülmesi sırasında eşleşen bir yakalama bloğu ile bir hata ortaya çıkarsa
hataya açık işlevBu yakalamak blok çalıştırılacaktır. Herhangi bir hata ortaya çıkmazsa, başka
blok yürütülür. bu nihayet blok olup olmadığına bakılmaksızın en son yürütülecektir.
hata yükseltildi.

olmadıkça
The olmadıkça makro yazmak için bir kısayol if verilip verilmediğini kontrol eden ifade
koşullu Yanlış. Aşağıda bu makronun genişletilmesi gösterilmektedir.

(koşullu ifade olmadıkça)

(şartlı ise
Hayır
(ifadesini yap))

tırnağı kapatmak
Yarı alıntı bir form içinde, tırnağı kapatmak bir sembolün değerlendirilmesini zorlar. tırnağı kapatmak takma ad
tilde (~) sembolü.

(tanım adı "Sarılmalar")
(quasiquote (= isim (alıntısız isim)))
;=> (u'=' u'name' u'Sarılmalar')

`(= isim ~isim)
;=> (u'=' u'name' u'Sarılmalar')

tırnak işareti
tırnak işareti bir sembolün yarı alıntılanmış bir form içinde değerlendirilmesini zorlar.
tırnağı kapatmak. tırnak işareti yalnızca alıntı yapılmayan sembol bir
yinelenebilir değer, çünkü yinelenebilir olanı yarı alıntılanmış forma "ekler". tırnak işareti is
takma ad ~@ sembolü.

(tanım sayıları [1 2 3 4])
(yarı alıntı (+ (alıntısız ek sayıları)))
;=> (u'+' 1L 2L 3L 4L)

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

ne zaman
ne zaman benzer olmadıkça, verilen koşullu olduğunda test etmesi dışında Gerçek. O değil
sahip olmak mümkün başka bir blok ne zaman makro. Aşağıdaki genişleme gösterir
makro.

(koşullu ifade olduğunda)

(şartlı ise (ifadeyi yapın))

süre
süre bir koşul karşılandığı sürece bir veya daha fazla bloğu yürütmek için kullanılır. Devamındaki
örnek "Merhaba dünya!" süresiz olarak ekrana:

(doğru iken ("Merhaba dünya!" yazdırın))

ile
ile bir bağlam yöneticisi içinde bir bloğun yürütülmesini sarmak için kullanılır. Bağlam
yönetici daha sonra yerel sistemi kurabilir ve kontrollü bir şekilde yıkabilir. bu
kullanmanın arketipsel örneği ile dosyaları işlerken. ile bağlamı bir
aşağıda gösterildiği gibi, argümanı tamamen yok sayın veya yok sayın:

([[arg (ifade)]] bloğu ile)

([[(expr)]] bloğu ile)

([[arg (ifade)] [(ifade)]] blok ile)

Aşağıdaki örnek, HABERLER dosya ve içeriğini ekrana yazdırın. bu
dosya işlendikten sonra otomatik olarak kapatılır.

([[f ("HABER" i açın)]] ile (yazdır (.read f)))

dekoratörlü
dekoratörlü bir işlevi başka bir işlevle sarmak için kullanılır. İşlevi gerçekleştiren
dekorasyon tek bir değeri kabul etmelidir: dekore edilen işlev ve yeni bir
fonksiyonu. dekoratörlü en az iki parametre alır: gerçekleştiren işlev
dekorasyon ve dekore edilen işlev. Birden fazla dekoratör işlevi olabilir
uygulamalı; en dıştan içe doğru sırayla uygulanacaktır, yani. ilk
dekoratör en dıştaki olacak, vb. Argümanları olan dekoratörlere sadece denir
bir işlev çağrısı gibi.

(dekoratörlü dekoratör-eğlenceli
(defn bir işlev [] ...)

(dekoratörlü dekoratör1 dekoratör2 ...
(defn bir işlev [] ...)

(dekoratörlü (dekoratör arg) ..
(defn bir işlev [] ...)

Aşağıdaki örnekte, inc-dekoratör işlevi süslemek için kullanılır ilave Birlikte
iki parametre alan ve dekore edilmiş işlevi şu değerlerle çağıran işlev
1 artırılır. Süslendiğinde ilave 1 ve 1 değerleri ile çağrılır, son
sonuç 4 olacak (1 + 1 + 1 + 1).

=> (defn inc-dekoratör [fonk]
... (fn [değer-1 değer-2] (fonk (+ değer-1 1) (+ değer-2 1))))
=> (defn inc2-dekoratör [fonk]
... (fn [değer-1 değer-2] (fonk (+ değer-1 2) (+ değer-2 2))))

=> (dekoratörlü inc-dekoratör (defn ekleme [ab] (+ ab)))
=> (ek 1 1)
4
=> (dekoratörlü inc2-dekoratörlü inc-dekoratörlü
... (defn ekleme [ab] (+ ab)))
=> (ek 1 1)
8

gensyms ile
0.9.12 sürümünde yeni.

gensym ile bir dizi oluşturmak için kullanılır jimnastik bir makroda kullanmak için. Aşağıdaki kod:

(gensyms ile [abc]
...)

genişler:

(izin [[a (gensym)
[b (gensim)
[c (gensim)]]
...)

GDA AYRICA:
Bölüm kullanma-gensym

verim
verim bir veya daha fazla değer döndüren bir oluşturucu nesnesi oluşturmak için kullanılır. jeneratör
yinelenebilir ve bu nedenle döngülerde, liste kavramalarında ve diğer benzerlerinde kullanılabilir
yapılar.

Bu fonksiyon rastgele numaralar sonsuz seriler oluşturmak için jeneratörlerin nasıl kullanılabileceğini gösterir
sonsuz miktarda bellek tüketmeden.

=> (defn çarpı [taban katsayıları]
... ([[(, taban katsayısı için) (zip taban katsayıları)]]
... (verim (* taban katsayısı))))

=> (çarpma (aralık 5) (aralık 5))


=> (list-comp değeri [değer (çarpma (aralık 10) (aralık 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (rastgele içe aktar)
=> (defn rastgele sayılar [düşük yüksek]
... (doğru iken (verim (.randint rasgele düşük yüksek))))
=> (list-comp x [x (15 (rastgele sayılar 1 50))])])
[7, 41, 6, 22, 32, 17, 5, 38, 18, 38, 17, 14, 23, 23, 19]

verim
0.9.13 sürümünde yeni.

PİTON 3.3 VE UP SADECE!

verim bir alt üreteci çağırmak için kullanılır. Bu, eşyordamınızın
gibi süslü bir şey kullanıyorsanız, süreçlerini başka bir eşyordama devredebilir
Asyncio.

Hy çekirdek
çekirdek fonksiyonlar
son
Kullanımı: (bütün kol)

içindeki son öğe hariç tümünün bir yineleyicisini döndürür coll.

=> (liste (son (aralık 10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8]

=> (liste (son [1]))
[]

=> (liste (son []))
[]

=> (itertools'u içe aktar)
=> (liste (5 al (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

kol?
0.10.0 sürümünde yeni.

Kullanımı: (kol? x)

Geri dönüşler Gerçek if x yinelenebilir ve bir dize değil.

=> (sıra? [1 2 3 4])
Gerçek

=> (sıra? {"a" 1 "b" 2})
Gerçek

=> (koll? "abc")
Yanlış

Cons
0.10.0 sürümünde yeni.

Kullanımı: (Eksileri a b)

Araba ile yeni bir eksiler hücresi döndürür a ve cdr b.

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

=> (= 'hd (araba a))
Gerçek

=> (= 'tl (cdr a))
Gerçek

aptallar?
0.10.0 sürümünde yeni.

Kullanımı: (Eksileri? foo)

olup olmadığını kontrol eder foo eksi hücredir.

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

=> (eksileri? a)
Gerçek

=> (eksileri? nil)
Yanlış

=> (eksileri? [1 2 3])
Yanlış

Aralık
Kullanımı: (aralık x)

Bir tane daha az döndürür x. Eşittir (- x 1). yükseltir TypeError if (Değil (sayısal? X)).

=> (3 ara)
2

=> (0 ara)
-1

=> (12.3 ara)
11.3

parçalarına ayırmak
0.10.0 sürümünde yeni.

Kullanımı: (sökmek ağaç &isteğe bağlı [kodegen YANLIŞ])

Verilen Hy için Python AST'yi boşaltın ağaç standart çıktıya. Eğer kodojen is Gerçek, işlev
bunun yerine Python kodunu yazdırır.

=> (sökün '("Merhaba Dünya!" yazdırın))
Modül(
vücut=[
İfade(değer=Çağrı(fonk=Ad(id='baskı'), args=[Str(s='Merhaba Dünya!')], anahtar kelimeler=[], starargs=Yok, kwargs=Yok))])

=> (demonte '("Merhaba Dünya!" yazdırın) true)
print('Merhaba Dünya!')

boş?
Kullanımı: (boş? kol)

Geri dönüşler Gerçek if coll boş. Eşittir (= 0 (sadece col)).

=> (boş mu? [])
Gerçek

=> (boş mu? "")
Gerçek

=> (boş mu? (, 1 2))
Yanlış

Her?
0.10.0 sürümünde yeni.

Kullanımı: (Her? önce kol)

Geri dönüşler Gerçek if (önceden x) mantıklı her şey için doğrudur x in coll, Aksi takdirde Yanlış. Dönüş Gerçek
if coll boş.

=> (her? çift? [2 4 6])
Gerçek

=> (her? çift? [1 3 5])
Yanlış

=> (her? çift? [2 4 5])
Yanlış

=> (her? çift mi? [])
Gerçek

batmadan yüzmek?
Kullanımı: (batmadan yüzmek? x)

Geri dönüşler Gerçek if x bir şamandıradır.

=> (yüzer? 3.2)
Gerçek

=> (yüzer mi? -2)
Yanlış

hatta?
Kullanımı: (Bile? x)

Geri dönüşler Gerçek if x eşittir. yükseltir TypeError if (Değil (sayısal? X)).

=> (çift mi? 2)
Gerçek

=> (çift mi? 13)
Yanlış

=> (çift mi? 0)
Gerçek

kimlik
Kullanımı: (Kimlik x)

İşleve sağlanan bağımsız değişkeni döndürür.

=> (kimlik 4)
4

=> (liste (harita kimliği [1 2 3 4]))
[1 2 3 4]

inc
Kullanımı: (dahil x)

Birden fazla döndürür x. Eşittir (+ x 1). yükseltir TypeError if (Değil (sayısal? X)).

=> (3 dahil)
4

=> (0 dahil)
1

=> (12.3 dahil)
13.3

örnek?
Kullanımı: (misal? sınıf x)

Geri dönüşler Gerçek if x bir örneği sınıf.

=> (örnek? kayan nokta 1.0)
Gerçek

=> (örnek? int 7)
Gerçek

=> (örnek? str (str "foo"))
Gerçek

=> (defclass TestClass [nesne])
=> (setv inst (TestClass))
=> (örnek? TestClass inst)
Gerçek

tamsayı?
Kullanımı: (tam sayı? x)

Geri dönüşler Gerçek if x bir tamsayıdır. Python 2 için bu ya int or ve kazandırdı. Python3 için,
bu int.

=> (tam sayı? 3)
Gerçek

=> (tam sayı? -2.4)
Yanlış

serpiştirmek
0.10.1 sürümünde yeni.

Kullanımı: (araya girmek SEQ1 SEQ2 ...)

Her bir dizideki ilk öğenin, ardından ikinci öğenin, vb. yinelenebilir bir değerini döndürür.

=> (liste (aralık (aralık 5) (aralık 100 105)))
[0, 100, 1, 101, 2, 102, 3, 103, 4, 104]

=> (liste (aralık (aralık 1000000) "abc"))
[0, 'a', 1, 'b', 2, 'c']

araya girmek
0.10.1 sürümünde yeni.

Kullanımı: (araya girmek madde sıra)

Öğeyle ayrılmış dizinin öğelerinin yinelenebilir bir halini döndürür.

=> (liste ("!" "abcd")
['a', '!', 'b', '!', 'c', '!', 'd']

=> (liste (araya giren -1 (aralık 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

yinelenebilir?
Kullanımı: (yinelenebilir? x)

Geri dönüşler Gerçek if x yinelenebilir. Yinelenebilir nesneler, şu durumlarda yeni bir yineleyici döndürür: (yine x) is
aranan. İle kontrast yineleyici?.

=> ;; dizeler için çalışır
=> (yinelenebilir? (str "abcde"))
Gerçek

=> ;; listeler için çalışır
=> (yinelenebilir? [1 2 3 4 5])
Gerçek

=> ;; tuples için çalışır
=> (yinelenebilir? (, 1 2 3))
Gerçek

=> ;; dicts için çalışır
=> (yinelenebilir? {:a 1 :b 2 :c 3})
Gerçek

=> ;; yineleyiciler/jeneratörler için çalışır
=> (yinelenebilir? (tekrar 3))
Gerçek

yineleyici?
Kullanımı: (yineleyici? x)

Geri dönüşler Gerçek if x bir yineleyicidir. Yineleyiciler, kendilerini bir
yineleyici ne zaman (yine x) denir. İle kontrast yinelenebilir?.

=> ;; bir liste için çalışmıyor
=> (yineleyici? [1 2 3 4 5])
Yanlış

=> ;; ama listeden bir yineleme alabiliriz
=> (yineleyici? (iter [1 2 3 4 5]))
Gerçek

=> ;; dict için çalışmıyor
=> (yineleyici? {:a 1 :b 2 :c 3})
Yanlış

=> ;; dict'den bir yineleyici oluştur
=> (yineleyici? (iter {:a 1 :b 2 :c 3}))
Gerçek

liste*
Kullanımı: (liste* baş &dinlenmek kuyruk)

Bağımsız değişkenleri içeren bir iç içe eksiler hücreleri zinciri (noktalı bir liste) oluşturur. Eğer
argüman listesinde yalnızca bir öğe var, onu döndür.

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

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

=> (liste* 1)
1

=> (eksileri? (list* 1 2 3 4))
Gerçek

makro genişletmek
0.10.0 sürümünde yeni.

Kullanımı: (makro genişletme formu)

Tam makro genişletmesini döndürür Airdrop Formu.

=> (makro genişletme '(-> (ab) (xy)))
(u'x' (u'a' u'b') u'y')

=> (makro genişletme '(-> (ab) (-> (cd) (ef))))
(u'e' (u'c' (u'a' u'b') u'd') u'f')

makrogenişlet-1
0.10.0 sürümünde yeni.

Kullanımı: (makrogenişletme-1 formu)

Şunun tek adımlı makro genişletmesini döndürür Airdrop Formu.

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

ile birleşmek
0.10.1 sürümünde yeni.

Kullanımı: (ile birleşmek f &dinlenmek haritalar)

İlk olarak birleştirilen geri kalan haritalardan oluşan bir harita döndürür. içinde bir anahtar oluşursa
birden fazla harita, ikincisinden (soldan sağa) eşleme(ler) ile birleştirilecektir.
arayarak sonuçtaki eşleme (f sonuç olarak val-in-late).

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

olumsuz mu?
Kullanımı: (negatif? x)

Geri dönüşler Gerçek if x sıfırdan küçüktür. yükseltir TypeError if (Değil (sayısal? X)).

=> (neg? -2)
Gerçek

=> (neg? 3)
Yanlış

=> (neg? 0)
Yanlış

sıfır?
Kullanımı: (sıfır? x)

Geri dönüşler Gerçek if x is sıfır / Hayır.

=> (sıfır? sıfır)
Gerçek

=> (sıfır? Yok)
Gerçek

=> (sıfır? 0)
Yanlış

=> (setf x nil)
=> (sıfır? x)
Gerçek

=> ;; list.append her zaman Yok döndürür
=> (nil? (.append [1 2 3] 4))
Gerçek

Yok?
Kullanımı: (Yok? x)

Geri dönüşler Gerçek if x is Hayır.

=> (yok mu? Yok)
Gerçek

=> (yok mu? 0)
Yanlış

=> (setf x Yok)
=> (hiçbiri? x)
Gerçek

=> ;; list.append her zaman Yok döndürür
=> (hiçbiri? (.append [1 2 3] 4))
Gerçek

n'inci
Kullanımı: (n. coll n &isteğe bağlı [varsayılan sıfır])

Döndürür n0'dan başlayarak bir koleksiyondaki -th öğesi. Varsayılan değeri döndür, sıfır, Eğer
sınırların dışında (aksi belirtilmedikçe). yükseltir Değer Hatası if n negatiftir.

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

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

=> (nil? (nth [1 2 4 7] 5))
Gerçek

=> (nth [1 2 4 7] 5 "varsayılan")
'varsayılan'

=> (n. (3'ü al (bırak 2 [1 2 3 4 5 6])) 2))
5

=> (nth [1 2 4 7] -1)
Geri izleme (en son yapılan arama):
...
ValueError: islice() için dizinler Yok veya bir tam sayı olmalıdır: 0 <= x <= sys.maxsize.

sayısal?
Kullanımı: (sayısal? x)

Geri dönüşler Gerçek if x Python'da tanımlandığı gibi bir sayısaldır sayılar.Numara sınıf.

=> (sayısal? -2)
Gerçek

=> (sayısal? 3.2)
Gerçek

=> (sayısal? "foo")
Yanlış

odd?
Kullanımı: (garip? x)

Geri dönüşler Gerçek if x garip. yükseltir TypeError if (Değil (sayısal? X)).

=> (tek? 13)
Gerçek

=> (tek? 2)
Yanlış

=> (tek? 0)
Yanlış

konum?
Kullanımı: (konum? x)

Geri dönüşler Gerçek if x sıfırdan büyüktür. yükseltir TypeError if (Değil (sayısal? X)).

=> (konum? 3)
Gerçek

=> (konum? -2)
Yanlış

=> (konum? 0)
Yanlış

ikinci
Kullanımı: (ikinci kol)

ikinci üyesini döndürür coll. Eşittir (almak coll 1).

=> (saniye [0 1 2])
1

biraz
0.10.0 sürümünde yeni.

Kullanımı: (bazı önce kol)

İlk mantıksal olarak doğru değerini döndürür (önceden x) herhangi x in coll, Aksi takdirde sıfır.
Dönüş sıfır if coll boş.

=> (bazıları eşit mi? [2 4 6])
Gerçek

=> (nil? (bazıları çift mi? [1 3 5]))
Gerçek

=> (nil? (bazı kimlik [0 "" []]))
Gerçek

=> (bazı kimlik [0 "boş olmayan dize" []])
'boş olmayan dize'

=> (nil? (hatta bazıları? []))
Gerçek

dize?
Kullanımı: (sicim? x)

Geri dönüşler Gerçek if x bir dizedir.

=> (dize? "foo")
Gerçek

=> (dize? -2)
Yanlış

sembol?
Kullanımı: (sembol? x)

Geri dönüşler Gerçek if x bir semboldür.

=> (sembol? 'foo)
Gerçek

=> (sembol? '[abc])
Yanlış

sıfır?
Kullanımı: (sıfır? x)

Geri dönüşler Gerçek if x sıfırdır.

=> (sıfır? 3)
Yanlış

=> (sıfır? -2)
Yanlış

=> (sıfır? 0)
Gerçek

Dizi fonksiyonlar
Sıra işlevleri, potansiyel olarak sonsuz bir diziyi oluşturabilir veya üzerinde çalışabilir.
sıranın bir liste veya benzer bir kapta tam olarak gerçekleştirilmesini gerektirir. Bunu onlar tarafından
bir Python yineleyici döndürme.

Nasıl kullanılacağına örnek olarak kanonik sonsuz Fibonacci sayı üretecini kullanabiliriz.
bu işlevlerden bazıları.

(tanım fib []
(ayar 0)
(ayar b 1)
(doğru iken
(verim a)
(setv (, ab) (, b (+ ab)))))

Not (süre gerçek ...) döngü. Bunu REPL'de çalıştırırsak,

=> (fib)


İşlevi çağırmak yalnızca bir yineleyici döndürür, ancak onu tüketene kadar hiçbir çalışmaz.
Sonsuz döngü bitene kadar çalışacağı için böyle bir şeyi denemek önerilmez.
mevcut tüm RAM'i tüketir veya bu durumda onu öldürene kadar.

=> (liste (fib))
[1] 91474 hy öldürdü

İlk 10 Fibonacci sayısını almak için şunu kullanın: almak. Bunu not et almak ayrıca bir jeneratör döndürür,
bu yüzden ondan bir liste oluşturuyorum.

=> (liste (10 (fib)) al)
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Fibonacci sayısını indeks 9'da almak için (0'dan başlayarak):

=> (n. (fib) 9)
34

devir
Kullanımı: (Çevrim kol)

coll üyelerinin sonsuz bir yineleyicisini döndürür.

=> (liste (7 al (döngü [1 2 3])))
[1, 2, 3, 1, 2, 3, 1]

=> (liste (2 al (döngü [1 2 3])))
[1, 2]

farklı
Kullanımı: (belirgin kol)

Yalnızca içindeki benzersiz üyeleri içeren bir yineleyici döndürür. coll.

=> (liste (farklı [ 1 2 3 4 3 5 2 ]))
[1, 2, 3, 4, 5]

=> (liste (farklı []))
[]

=> (liste (farklı (iter [ 1 2 3 4 3 5 2 ])))
[1, 2, 3, 4, 5]

düşürmek
Kullanımı: (düşürmek n kol)

İlkini atlayarak bir yineleyici döndürür n üyeleri coll. yükseltir Değer Hatası if n is
Negatif.

=> (liste (bırak 2 [1 2 3 4 5]))
[3, 4, 5]

=> (liste (bırak 4 [1 2 3 4 5]))
[5]

=> (liste (bırak 0 [1 2 3 4 5]))
[1, 2, 3, 4, 5]

=> (liste (bırak 6 [1 2 3 4 5]))
[]

son damla
Kullanımı: (son bırak n kol)

Sonuncusu hariç hepsinin bir yineleyicisini döndürür n içindeki öğeler coll. yükseltir Değer Hatası if n is
Negatif.

=> (liste (son 5'i bırak (aralık 10 20)))
[10, 11, 12, 13, 14]

=> (liste (son bırak 0 (aralık 5)))
[0, 1, 2, 3, 4]

=> (liste (son bırak 100 (aralık 100)))
[]

=> (itertools'u içe aktar)
=> (liste (5 al (son 100 bırak (itertools.count 10))))
[10, 11, 12, 13, 14]

düşerken
Kullanımı: (bırakırken önce kol)

Üyelerini atlayarak bir yineleyici döndürür coll kadar önce is Yanlış.

=> (liste (hatta düşerken? [2 4 7 8 9]))
[7, 8, 9]

=> (liste (sayısal iken bırakma? [1 2 3 Yok "a"])))
[Yok, u'a']

=> (liste (bırak-poz? [2 4 7 8 9]))
[]

filtre
Kullanımı: (filtre önce kol)

içindeki tüm öğeler için bir yineleyici döndürür coll yüklemi geçen önce.

Ayrıca bakınız Kaldır.

=> (liste (filtre konumu? [1 2 3 -4 5 -7]))
[1, 2, 3, 5]

=> (liste (çift filtre? [1 2 3 -4 5 -7]))
[2, -4]

düzleştirmek
0.9.12 sürümünde yeni.

Kullanımı: (düzleştirmek kol)

içindeki tüm öğelerin tek bir listesini döndürür coll, içerilen tüm listeleri düzleştirerek ve/veya
demetler.

=> (düzleştir [1 2 [3 4] 5])
[1, 2, 3, 4, 5]

=> (düzleştir ["foo" (, 1 2) [1 [2 3] 4] "çubuk"])
['foo', 1, 2, 1, 2, 3, 4, 'çubuk']

yinelemek
Kullanımı: (yineleme fn x)

Bir yineleyici döndürür x, fn(x), fn(fn(x)), vb.

=> (liste (5'i alın (5'i yineleyin)))
[5, 6, 7, 8, 9]

=> (liste (5 al (yinele (fn [x] (* xx)) 5)))
[5, 25, 625, 390625, 152587890625]

okumak
Kullanımı: (okuma &isteğe bağlı [dosyadan eof])

Bir sonraki Hy ifadesini okur dosyadan (varsayılan olarak sistem.stdin) ve alabilir
EOF olarak tek bayt (varsayılan olarak boş bir dizedir). yükseltir EOFE Hatası if dosyadan önce biter
tam bir ifade ayrıştırılabilir.

=> (okuyun)
(+2)
('+' 2 2)
=> (değerlendir (oku)
(+2)
4

=> (içe içe aktar)
=> (def arabelleği (io.StringIO "(+ 2 2)\n(- 2 1)"))
=> (değerlendirme (okuma [] {"from_file" arabelleği}) uygulayın)
4
=> (değerlendirme (okuma [] {"from_file" arabelleği}) uygulayın)
1

=> ; "example.hy"nin şunları içerdiğini varsayarsak:
=> ; ("merhaba" yazdırın)
=> ; ("arkadaşlar!" yazdırın)
=> ([[f ("example.hy"yi açın) ile]]]
... (denemek
... (doğru iken
... (bırak [[exp (f oku)]]
... (yapmak
... ("OHY" ifadesini yazdırın)
... (değerlendirme exp))))
... ([e EOFError] yakalayın
... ("EOF!" yazdırın))))
OHY ('yazdır' 'merhaba')
merhaba
OHY ('yazdır' 'arkadaşlar!')
sevgililer!
EOF!

Kaldır
Kullanımı: (Kaldır önce kol)

Şundan bir yineleyici döndürür coll yüklemi geçen öğelerle, önce, kaldırıldı.

Ayrıca bakınız filtre.

=> (liste (tek sayısı kaldırılsın mı? [1 2 3 4 5 6 7]))
[2, 4, 6]

=> (liste (konumu kaldır? [1 2 3 4 5 6 7]))
[]

=> (liste (neg'i kaldır? [1 2 3 4 5 6 7]))
[1, 2, 3, 4, 5, 6, 7]

tekrar et
Kullanımı: (tekrarlamak x)

Bir yineleyici (sonsuz) döndürür x.

=> (liste (6'yı alın ("s"yi tekrarlayın)))
[sen', sen', sen', sen', sen', sen']

defalarca
Kullanımı: (defalarca fn)

Çağırarak bir yineleyici döndürür fn defalarca.

=> ([rastgele [random]] içe aktar)

=> (liste (5 tane al (tekrar tekrar (fn [] (randint 0 10))))
[6, 2, 0, 6, 7]

almak
Kullanımı: (almak n kol)

İlki içeren bir yineleyici döndürür n üyeleri coll. yükseltir Değer Hatası if n is
Negatif.

=> (liste (3 [1 2 3 4 5] alın))
[1, 2, 3]

=> (liste (4'yı alın ("s"yi tekrarlayın)))
[sen', sen', sen', sen']

=> (liste (0'yı alın ("s"yi tekrarlayın)))
[]

nth almak
Kullanımı: (al-nth n kol)

Her içeren bir yineleyici döndürür n-inci üye coll.

=> (liste (n. 2 [1 2 3 4 5 6 7]))
[1, 3, 5, 7]

=> (liste (n. 3 [1 2 3 4 5 6 7]))
[1, 4, 7]

=> (liste (n. 4 [1 2 3 4 5 6 7]))
[1, 5]

=> (liste (n. 10 [1 2 3 4 5 6 7]))
[1]

zaman geçirmek
Kullanımı: (alışkanlık önce kol)

Şundan bir yineleyici döndürür coll olduğu sürece önce İade Gerçek.

=> (liste (alma pozisyonu? [ 1 2 3 -4 5]))
[1, 2, 3]

=> (liste (alınan süre neg? [ -4 -3 1 2 5]))
[-4, -3]

=> (liste (alınan süre neg? [ 1 2 3 -4 5]))
[]

zip ile
0.9.13 sürümünde yeni.

Kullanımı: (zip ile fn coll ...)

Eşittir zip, ancak bir tanımlama grubu oluşturmak yerine çoklu bağımsız değişken işlevi kullanır. Eğer
zip ile N koleksiyonları ile çağrılır, sonra fn N argümanı kabul etmelidir.

=> (içe aktarma operatörü)
=> (liste (zip ile operatör.add [1 2 3] [4 5 6]))
[5, 7, 9]

Okuyucu Makrolar
Okuyucu makroları, Lisp'e anında sözdizimini değiştirme ve değiştirme gücü verir. istemiyorsun
Polonya notasyonu? Bir okuyucu makrosu bunu kolayca yapabilir. Clojure'un sahip olma yolunu istiyorum
normal ifade? Okuyucu makroları da bunu kolayca yapabilir.

Sözdizimi
=> (defreader ^ [ifade] (baskı ifadesi))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Merhaba"
"Merhaba"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

Hy'nin tupleler için değişmez değeri yoktur. beğenmedin diyelim (, ...) ve başka bir şey istiyorum. Bu
makroların düzgün bir şekilde çözebildiği bir problem okuyucudur.

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

Hatta Clojure gibi yapabilir ve düzenli ifadeler için bir hazır bilginiz olabilir!

=> (yeniden içe aktar)
=> (defreader r [ifade] `(yeniden derleme ~ifade))
=> #r".*"
<_sre.SRE_Pattern nesnesi 0xcv7713ph15#> konumunda

Uygulama
koruyucu okuyucu makrosu için sembol adı olarak tek bir karakter alır; daha uzun bir şey
bir hata döndürür. Uygulama açısından, koruyucu ile kaplanmış bir lambdaya genişler.
dekoratör. Bu dekoratör, lambda'yı modül adıyla bir sözlükte kaydeder ve
sembolü.

=> (defreader ^ [ifade] (baskı ifadesi))
;=> (with_decorator (hy.macros.reader ^) (fn [ifade] (baskı ifadesi)))

# genişler (dispatch_reader_macro ...) sembol ve ifadenin geçirildiği yer
doğru işlev.

=> #^()
;=> (dispatch_reader_macro ^ ())
=> #^"Merhaba"
"Merhaba"

UYARI:
Hy'ın sözlük ve ayrıştırıcısındaki bir sınırlama nedeniyle, okuyucu makroları tanımlı tanımları yeniden tanımlayamaz
sözdizimi gibi ()[][][}. Bu büyük olasılıkla gelecekte ele alınacaktır.

İç Hy belgeleme
NOT:
Bu bitler çoğunlukla Hy'ın kendisini hackleyen insanlar için faydalıdır, ancak aynı zamanda aşağıdakiler için de kullanılabilir.
makro programlamada daha derine inenler.

Hy Modeller
Giriş için Hy Modeller
Hy modelleri, normal Python nesnelerinin üzerinde Hy kaynağını temsil eden çok ince bir katmandır.
veri olarak kodlayın. Modeller yalnızca kaynak konum bilgisi ve bir avuç yöntem ekler.
örneğin makrolarda Hy kaynak kodunun temiz manipülasyonunu destekler. Bunu başarmak için
amaç, Hy modelleri temel bir Python sınıfının karışımlarıdır ve HyObject.

HyObject
hy.models.HyObject Hy modellerinin temel sınıfıdır. Yalnızca bir yöntemi uygular, değiştirmek,
bu, geçerli nesnenin kaynak konumunu argüman olarak iletilen konumla değiştirir.
Bu, tarafından değiştirilen ifadelerin orijinal konumunu takip etmemizi sağlar.
makrolar, derleyicide veya saf hy makrolarında olsun.

HyObject doğrudan Hy modellerini başlatmak için değil, yalnızca bir karışım olarak kullanılmak üzere tasarlanmıştır.
diğer sınıflar için.

Bileşik Modeller
Parantez içindeki ve parantez içindeki listeler, Hy ayrıştırıcısı tarafından bileşik modeller olarak ayrıştırılır.

HyList
hy.models.list.HyList "yinelenebilir" Hy modellerinin temel sınıfıdır. Temel kullanımı,
parantez içinde temsil [] üst düzey bir ifade olarak kullanıldığında,
Python, derleme aşamasında değişmezleri listeler.

Başka bir yinelenebilir nesneye bir HyList eklemek, sol taraftaki nesnenin sınıfını yeniden kullanır,
örneğin bir makroda Hy nesnelerini birleştirmek istediğinizde yararlı bir davranış.

HyExpression
hy.models.expression.HyExpression devralır HyList parantez içinde () ifade. bu
bu ifadelerin derleme sonucu, listenin ilk öğesine bağlıdır:
derleyici, derleyici özel formları, kullanıcı tanımlı makrolar ve
normal Python işlev çağrıları.

HyDict
hy.models.dict.HyDict devralır HyList kıvırcık parantez için {} derleyen ifadeler
bir Python sözlüğü değişmezine kadar.

için temel sınıf olarak bir dict yerine bir liste kullanma kararı HyDict daha kolay sağlar
Bileşik ifadelere izin vermenin ek yararı ile makrolarda dicts manipülasyonu
dict tuşları olarak (örneğin, HyExpression Python sınıfı hashable değildir).

Atomic Modeller
Girdi akışında, dizeler için Python gösterimine uygun olarak çift tırnaklı dizeler,
doğrudan bir olarak ayrıştırılan tek bir belirteç olarak ayrıştırılır HyString.

Boşluklar, parantezler, tırnaklar ve çift tırnaklar hariç, kesintisiz bir karakter dizisi
ve yorumlar, bir tanımlayıcı olarak ayrıştırılır.

Tanımlayıcılar, ayrıştırma aşaması sırasında aşağıdaki sırayla atomik modellere çözümlenir:

· HyTamsayı

· HyFloat

· HyComplex (eğer atom çıplak değilse j)

· HyKeyword (eğer atom ile başlarsa :)

· HySymbol

HyString
hy.models.string.HyString dize eşdeğeri Hy modellerinin temel sınıfıdır. Ayrıca
çift ​​tırnaklı dize değişmezlerini temsil eder, "", unicode dizeye derlenen
Python'daki değişmezler. HyString'ler Python 2'de unicode nesneleri ve içindeki dize nesnelerini devralır.
Python 3 (ve bu nedenle kodlamaya bağımlı değildir).

HyString tabanlı modeller değişmezdir.

Hy değişmez dizeleri birden çok satıra yayılabilir ve ayrıştırıcı tarafından tek bir satır olarak kabul edilir.
birim, unicode dizeleri için Python çıkışlarına saygı gösterir.

Sayısal Modeller
hy.models.integer.HyInteger tamsayı değişmezlerini temsil eder (kullanarak ve kazandırdı Python 2'ye yazın,
ve int Python 3) üzerinde.

hy.models.float.HyFloat kayan nokta değişmezlerini temsil eder.

hy.models.complex.HyComplex karmaşık değişmezleri temsil eder.

Sayısal modeller, karşılık gelen Python rutini ve geçerli sayısal python kullanılarak ayrıştırılır
değişmezler Hy karşılıklarına dönüştürülecektir.

HySymbol
hy.models.symbol.HySymbol Hy dilinde sembolleri temsil etmek için kullanılan modeldir. o
devralır HyString.

HySymbol Python birlikte çalışabilirliğine yardımcı olmak için nesneler ayrıştırma aşamasında karıştırılır:

· Yıldızlarla çevrili semboller (*) büyük harfe dönüştürülür;

· Kısa çizgiler (-) alt çizgiye dönüştürülür (_);

· Sondaki bir soru işareti (?) lidere dönüştürülür dır-dir_.

Uyarı: parçalama, ayrıştırma aşamasında yapıldığından,
Hy kaynak koduyla oluşturulamayan HySymbol'leri programlı olarak oluşturun. böyle bir
mekanizma, gensym tarafından "internetlenmemiş" semboller üretmek için kullanılır.

HyKeyword
hy.models.anahtar kelime.HyKeyword Hy'daki anahtar kelimeleri temsil eder. Anahtar kelimeler ile başlayan sembollerdir
a :. sınıf miras alır HyString.

Ayırt etmek Anahtar Kelimeler itibaren HySimboller, imkanı olmadan (istem dışı)
çakışmalar, özel kullanımlı unicode karakter "\uFDD0" değişmez anahtar kelimenin başına eklenir
depolamadan önce.

Eksiler Hücreler
hy.models.cons.HyCons Python dostu temsilidir Cons hücreler. eksileri hücreler
Scheme veya Common gibi "olağan" LISP varyantlarının özelliklerini taklit etmek için özellikle yararlıdır
Lisp.

Eksi hücresi, 2 öğeli bir nesnedir ve bir araba (kafa) ve bir cdr (kuyruk). Bazı Lisp'te
varyantlar, eksiler hücresi temel yapı taşıdır ve S-ifadeleri aslında
eksiler hücrelerinin bağlantılı listeleri olarak temsil edilir. Her zamanki gibi Hy'da durum böyle değil
ifadeler, bir dizi içine sarılmış Python listelerinden yapılır. HyExpression. Bununla birlikte, HyCon'lar
"olağan" Lisp değişkenlerinin davranışını şu şekilde taklit eder:

· (Eksileri bir şey sıfır) is (HyExpression [bir şey])

· (Eksileri bir şey bazı liste) is ((tip bazı liste) (+ [bir şey] bazı liste)) (Eğer
bazı liste miras liste).

· (almak (Eksileri a b) 0) is a

· (dilim (Eksileri a b) 1) is b

Hy noktalı liste sözdizimini destekler, burada '(a . b) anlamına geliyor (Eksileri 'a 'B) ve '(a b . c) anlamına geliyor
(Eksileri 'a (Eksileri 'b 'C)). Derleyici en üst düzeyde bir eksiler hücresiyle karşılaşırsa,
bir derleme hatası.

HyCon'lar manipülasyonunu kolaylaştırmak için, geçirilen argümanları (car ve cdr) Hy tiplerinde sarar.
eksileri hücreler bir makro bağlamında.

Hy İç teori
Genel Bakış
Hy'ın dahili bileşenleri, Python bayt kodunun ön ucu olarak hareket ederek çalışır, böylece Hy'ın kendisi
Python Bayt kodunu derler ve değiştirilmemiş bir Python çalışma zamanının Hy kodunu çalıştırmasına izin verir,
farkına bile varmadan.

Bunu yapmanın yolu, Hy'yi dahili bir Python AST veri yapısına çevirmektir ve
Python standardındaki modülleri kullanarak AST'yi Python bayt koduna dönüştürmek
kütüphane, böylece Python'un içindekilerin tüm çalışmalarını her biri için çoğaltmak zorunda kalmayacağız.
tek Python sürümü.

Hy dört aşamada çalışır. Aşağıdaki bölümler, Hy'nin kaynaktan
Çalışma süresi.

Basamaklar 1 ve 2: tokenizing ve ayrıştırma
Hy'yi derlemenin ilk aşaması, kaynağı başa çıkabileceğimiz belirteçlere dönüştürmektir. Biz
bir alt kümede yazılmış gerçekten güzel (ve hızlı) bir ayrıştırıcı olan rply adlı bir proje kullanın
Python'un adı rpython.

Lexing kodunun tamamı şurada tanımlanmıştır: hy.lex.lexer. Bu kod çoğunlukla sadece Hy'yi tanımlar.
dilbilgisi ve tüm gerçek zor kısımlar rply ile halledilir -- biz sadece
rply için "geri aramalar" hy.lex.parserüretilen belirteçleri alan ve
Modeller.

Hy modellerini Hy için "AST" olarak düşünebilirsiniz, Makrolar bunun üzerinde çalışır
(doğrudan) ve derleyicinin Hy'ı derlerken kullandığı şey budur.

GDA AYRICA:
Bölüm Hy Modeller Hy modelleri ve ne anlama geldikleri hakkında daha fazla bilgi için.

adım 3: Hy Derleme için Python AST
Hy'daki sihrin çoğu burada gerçekleşir. Hy AST'yi (modelleri) aldığımız yer burasıdır,
ve bunları Python AST'de derleyin. Birkaç korkak şey burada birkaçını geçmek için olur
AST'deki problemler ve derleyicide çalışmak yaptığımız en önemli işlerden bazıları.
var.

Derleyici biraz karmaşıktır, bu yüzden ilk atışta grok yapmazsanız kendinizi kötü hissetmeyin.
düzelmesi biraz zaman alabilir.

Derleyiciye ana giriş noktası HyASTCompiler.derleme. Bu yöntem çağrılır ve
sınıftaki tek gerçek "genel" yöntem (yani,
API, bu yöntemin ötesinde).

Aslında, içsel olarak bile, hemen hemen hiçbir zaman doğrudan yinelemiyoruz, neredeyse her zaman zorluyoruz.
aracılığıyla Hy ağacı derlemek, ve bunu genellikle bir ifadenin alt öğeleriyle yapar
sahip olduğumuz. Alt öğeleri düzgün bir şekilde göndermek, Tip tabanlı göndericiye bağlıdır.

Bir derlemeyi önceden oluşturan tüm yöntemler ile işaretlenmiştir. @yapılar() dekoratör. Yapabilirsiniz
ya derlediği Hy modelinin sınıfını iletin ya da bir dize kullanabilirsiniz.
ifade. Bunu bir saniye içinde açıklayacağım.

Ad Aşama Tip-Sevk
içinde başlayalım derlemek yöntem. Yaptığımız ilk şey, şeyin Türünü kontrol etmektir.
inşa ediyoruz. oluşturabilecek bir yöntemimiz olup olmadığını görmek için yukarıya bakıyoruz. tip() Böylece biz
sahip olun ve onu işleyebilecek yönteme gönderin. Yapabilecek herhangi bir yöntemimiz yoksa
bu türü inşa edin, bir iç Istisna.

Örneğin, eğer bir HyString, Hy AST'nin Python ile neredeyse 1'e 1 eşlenmesine sahibiz
AST. bu derleme_dizesi yöntem alır HyString, ve bir döndürür ast.Str()
doğru satır numaraları ve içerikle doldurulur.

Makro-Genişlet
bir alırsak HyExpression, bunun bilinen bir Makro olup olmadığını görmeye çalışacağız ve
çağırarak genişletti hy.makros.makrogenişlet, ardından sonucu geri itin
HyASTCompiler.derleme.

İkinci Aşama İfade-Sevk
Tek özel durum, HyExpression, bağlı olarak farklı AST oluşturmamız gerektiğinden
söz konusu özel formda. Örneğin, bir yere çarptığımızda (Eğer gerçek gerçek YANLIŞ), Biz
bir oluşturmak gerekir ast.eğerve alt düğümleri uygun şekilde derleyin. Burası @yapılar()
bir argüman olarak bir String ile gelir.

Için derleme_ifadesi (bir ile tanımlanır @builds(HyExpression)) sevk edecek
ilk argümanın dizesine göre. Herhangi bir nedenle, ilk argüman değilse
bir dize, bu durumu da düzgün bir şekilde ele alacaktır (büyük olasılıkla bir Istisna).

Dize Hy tarafından bilinmiyorsa, varsayılan olarak bir ast.çağrı, deneyecek olan
bir çalışma zamanı çağrısı yapın (Python'da şöyle bir şey foo ()).

Sorunlar vurmak ile Python AST
Python AST harika; üzerine böylesine güçlü bir proje yazmamızı sağlayan şey buydu.
Python ile çok fazla savaşmak zorunda kalmadan Python. Her şeyde olduğu gibi, payımıza düşeni aldık
sorunlar ve işte karşılaşabileceğiniz yaygın sorunların kısa bir listesi.

Python diferansiyatları arasında Tablolar ve İfadeler.

Bu çok büyük bir şey gibi gelmeyebilir - aslında, çoğu Python programcısı için bu
kısa bir süre sonra bir "Eh, evet" anı haline gelir.

Python'da şöyle bir şey yapmak:

baskı için x in menzil(10): geçmekÇünkü, baskı ifadeleri yazdırır ve için bir değil
ifadesi, bir kontrol akışı ifadesidir. Gibi şeyler 1 + 1 olduğu gibi İfadelerdir lambda
x: 1 + x, ancak diğer dil özellikleri, örneğin if, içinya da süre ifadelerdir.

Python için "değerleri" olmadığı için, bu, Hy'da çalışmayı zorlaştırır, çünkü bir şeyler yapmaktan beri
sevmek (Yazdır (Eğer gerçek gerçek YANLIŞ)) sadece yaygın değil, bekleniyor.

Sonuç olarak, bir şeyi kullanarak şeyleri otomatik olarak yönetiriz. Sonuç herhangi bir teklif sunduğumuz nesne ast.stmt
kaçması gereken ve tek bir ast.ifade ne olursa olsun değerini elde etmek için kullanılabilir
sadece çalıştırıldı. Hy bunu koşarken bir şeylere atama yapmaya zorlayarak yapar.

Örneğin, Hy:

(yazdır (doğruysa doğruysa yanlış))

dönüşecek:

Eğer doğruysa:
_mangled_name_here = Doğru
Başka:
_mangled_name_here = Yanlış

_mangled_name_buraya yazdır

Tamam, bu biraz yalandı, çünkü aslında bu ifadeyi şuna çeviriyoruz:

True ise True veya False yazdır

Bir şeyleri zorlayarak ast.ifade eğer yapabilirsek, ancak genel fikir geçerlidir.

adım 4: Python Bayt kodu Çıktı ve Süre
Tamamlanmış bir Python AST ağacımız olduktan sonra, onu Python'a derlemeye çalışabiliriz.
iterek bytecode değerlendirme. Şu andan itibaren, kontrol artık bizde değil ve
Python her şeyi hallediyor. Bu nedenle Python geri izleme, pdb ve
django uygulamaları çalışır.

Hy Makrolar
kullanma jimnastik için Daha güvenli Makrolar
Makro yazarken, harici değişkenleri yakalamaktan veya kullanmaktan kaçınmak için dikkatli olunmalıdır.
kullanıcı koduyla çakışabilecek değişken adları.

Örnek bir makro kullanacağız nif (görmek
http://letoverlambda.com/index.cl/guest/chap3.html#sec_5 daha eksiksiz bir açıklama için.)
nif bir örnek, sayısal gibi bir şey if, ifadeye göre, aşağıdakilerden biri
İfadenin pozitif, sıfır veya negatif olmasına göre 3 form çağrılır.

İlk geçiş şöyle bir şey olabilir:

(defmacro nif [expr pos-form sıfır-form negatif-form]
`(izin [[belirsiz-ad ~ifade]]
(koşul [(kon? belirsiz-ad) ~pos-formu]
[(sıfır? belirsiz ad) ~sıfır biçim]
[(neg? belirsiz-ad) ~neg-form])))

nerede belirsiz isim diğerleriyle çakışmamak için bazı değişken adlarını seçme girişimidir.
kod. Ama elbette, iyi niyetli olsa da, bu bir garanti değildir.

Gensym yöntemi, tam da böyle bir durum için yeni, benzersiz bir sembol oluşturmak üzere tasarlanmıştır.
çok daha iyi bir versiyonu nif olabilir:

(defmacro nif [expr pos-form sıfır-form negatif-form]
(izin [[g (gensym)]]
`(izin [[~g ~ifade]]
(koşul [(kon? ~g) ~pos-formu]
[(sıfır? ~g) ~sıfır-form]
[(neg? ~g) ~neg-form]))))

Sadece bir sembol olduğu için bu kolay bir durumdur. Ama eğer birkaç taneye ihtiyaç varsa
gensym'de, temelde bir diziye genişleyen gensyms'li ikinci bir makro vardır. izin
ifadeleri:

(gensyms ile [abc]
...)

genişler:

(izin [[a (gensym)
[b (gensim)
[c (gensim)]]
...)

yani yeniden yazdık nif Benzeyecekmiş gibi:

(defmacro nif [expr pos-form sıfır-form negatif-form]
(gensyms ile [g]
`(izin [[~g ~ifade]]
(koşul [(kon? ~g) ~pos-formu]
[(sıfır? ~g) ~sıfır-form]
[(neg? ~g) ~neg-form]))))

Son olarak, tüm bunları bizim için yapan yeni bir makro yapabiliriz. defmakro/g! alacak
ile başlayan tüm semboller g! ve otomatik olarak ara jimnastik geri kalanı ile
sembol. Böyle g!a olacaktı (gensim "a").

Son versiyonumuz nifile inşa edildi defmakro/g! dönüşür:

(defmacro/g! nif [ifade pos-form sıfır-form negatif-form]
`(izin [[~g!res ~ifade]]
(koşul [(kon? ~g!res) ~pos-formu]
[(sıfır? ~g!res) ~sıfır-form]
[(neg? ~g!res) ~neg-formu]))))

Denetleme Makro Argümanlar ve Kaldırma İstisnalar
Hy derleyici Yerleşikler

katılımcının MODÜLLER INDEX

İçindekiler:

Anaforik Makrolar
0.9.12 sürümünde yeni.

Anaforik makrolar modülü, Hy'da işlevsel programlamayı çok özlü ve kolay hale getirir.
okuyun.
Bir anaforik makro, kasıtlı olarak bazı formları yakalayan bir programlama makrosu türüdür.
bir anafor tarafından atıfta bulunulabilecek makroya sağlanan
başka bir). — Vikipedi (http://en.wikipedia.org/wiki/Anaphoric_macro)

Makrolar
ap-eğer
Kullanımı: (ap-eğer (foo) (Yazdır o))

Doğruluk için ilk formu değerlendirir ve ona bağlar. it hem doğru hem yanlış olarak
dalları.

şeftali
Kullanımı: (şeftali [1 2 3 4 5] (Yazdır o))

Yan etkiler için listedeki her öğenin formunu değerlendirin.

ap-ever-while
Kullanımı: (ap-ever-while liste önce vücut)

Yüklem formunun döndüğü her öğe için formu değerlendirin Gerçek.

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

ap-harita
Kullanımı: (ap-harita Airdrop Formu liste)

Haritanın anaforik biçimi, bir işlev yerine normal harita gibi çalışır.
nesne bir Hy formu alır. özel isim it şu anki nesneye bağlı
yinelemedeki liste.

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

ap-harita-ne zaman
Kullanımı: (ap-harita-ne zaman tercih temsilci liste)

Ne zaman uygulanacağını belirlemek için bir yüklem işlevi kullanarak liste üzerinden bir eşlemeyi değerlendirin.
Form.

=> (liste (ap-harita-tek olduğunda? (* it 2) [1 2 3 4]))
[2, 2, 6, 4]

=> (liste (ap-map-ne zaman bile? (* it 2) [1 2 3 4]))
[1, 4, 3, 8]

ap filtresi
Kullanımı: (ap-filtre Airdrop Formu liste)

Ile ap-harita öğelerini filtrelemek için bir işlev yerine özel bir biçim alıyoruz.
liste. özel isim it yinelemedeki geçerli öğeye bağlıdır.

=> (liste (ap-filtre (> (* it 2) 6) [1 2 3 4 5]))
[4, 5]

ap-reddetmek
Kullanımı: (ap-reddetme Airdrop Formu liste)

Bu fonksiyon tersini yapar ap filtresi, geçen öğeleri reddeder.
yüklem özel isim it yinelemedeki geçerli öğeye bağlıdır.

=> (liste (ap-reddetme (> (* it 2) 6) [1 2 3 4 5]))
[1, 2, 3]

ap-dotimes
kullanım (ap-dotimes n vücut)

Bu fonksiyon vücudu değerlendirir n kez, özel değişkenle it bağlı 0 için
1-n. Yan etkiler için faydalıdır.

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

ap-ilk
kullanım (ap-ilk tercih liste)

Bu işlev, yüklemi geçen ilk öğeyi döndürür veya Hayır, Birlikte
özel değişken it yinelemedeki geçerli öğeye bağlı.

=>(ap-first (> it 5) (aralık 10))
6

ap-son
kullanım (ap-son tercih liste)

Bu işlev, yüklemi geçen son öğeyi döndürür veya Hayır, özel
değişken it yinelemedeki geçerli öğeye bağlı.

=>(ap-last (> it 5) (aralık 10))
9

ap-azaltma
kullanım (ap-azaltma Airdrop Formu liste &isteğe bağlı başlangıç ​​değeri)

Bu işlev, gövdedeki ilk 2 öğeye form uygulamanın sonucunu döndürür ve
liste tükenene kadar sonucu ve 3. öğeyi vb. uygulamak. İsteğe bağlı olarak bir
başlangıç ​​değeri sağlanabilir, böylece fonksiyon başlangıç ​​değerine uygulanır ve
yerine ilk eleman. Bu, yinelenen öğeyi şu şekilde gösterir: it Ve mevcut
olarak birikmiş değer acc.

=>(ap-reduce (+ it acc) (aralık 10))
45

döngü/tekrar
0.10.0 sürümünde yeni.

The döngü / yinelemek makro, programcılara kuyruk çağrısı optimizasyonunu (TCO) kullanmanın basit bir yolunu sunar
onların Hy kodunda.
Kuyruk çağrısı, nihai olarak başka bir prosedürün içinde gerçekleşen bir alt program çağrısıdır.
eylem; çağrı tarafından hemen döndürülen bir dönüş değeri üretebilir.
prosedür. Bir altyordamın gerçekleştirdiği herhangi bir çağrı, sonunda yol açabilecek şekilde
Çağrı zincirinde tekrar çağrılan bu aynı alt programa kuyruk pozisyonundadır,
böyle bir altyordamın, özyinelemenin özel bir durumu olan kuyruk özyinelemeli olduğu söylenir.
Kuyruk çağrıları önemlidir çünkü yeni bir yığın eklemeden uygulanabilmektedir
çağrı yığınına çerçeve. Mevcut prosedürün çerçevesinin çoğuna herhangi bir ihtiyaç duyulmamaktadır.
daha fazlası ve kuyruk çağrısının çerçevesi ile değiştirilebilir. Program daha sonra atlayabilir
çağrılan alt programa. Standart bir arama dizisi yerine böyle bir kod üretmek,
kuyruk çağrısı eleme veya kuyruk çağrısı optimizasyonu denir. Kuyruk çağrısı ortadan kaldırılmasına izin verir
kuyruk pozisyonundaki prosedür çağrıları, goto ifadeleri kadar verimli bir şekilde uygulanacak,
böylece verimli yapılandırılmış programlamaya izin verir. — Vikipedi (‐
http://en.wikipedia.org/wiki/Tail_call)

Makrolar
döngü
döngü bir özyineleme noktası oluşturur. İle döngü, yinelemek içinde ayarlanan değişkenleri yeniden bağlar
özyineleme noktası ve kod yürütmesini bu özyineleme noktasına geri gönderir. Eğer yinelemek kullanılan
kuyruk olmayan bir konum, bir istisna atılır.

Kullanımı: (döngü bağlamaları &dinlenmek vücut)

Örnek:

(hy.contrib.loop gerektirir)

(def faktöriyel [n]
(döngü [[in] [acc 1]]
(eğer (sıfır? i)
acc
(tekrar (dec i) (* acc i)))))

(faktöriyel 1000)

Defmulti
0.10.0 sürümünde yeni.

Defmulti verilen argüman ve/veya kwarg sayısına göre bir fonksiyona aşırı yükleme yapmanızı sağlar.
Clojure'un üstlenişinden ilham aldı tanım.

=> (hy.contrib.multi gerektirir)
=> (çoklu eğlence
... ([a] "a")
... ([ab] "ab")
... ([abc] "abc"))
=> (eğlence 1)
"A"
=> (eğlence 1 2)
"ab"
=> (eğlence 1 2 3)
"ABC"

HACKING ON HY

Kaydol bizim Hyve!
Lütfen gelip Hy'ı hackleyin!

Lütfen gel bizimle takıl #hey on irc.freenode.net!

Lütfen bunun hakkında Twitter'da konuşun #hey başlık etiketi!

Lütfen bunun hakkında blog yazın!

Lütfen komşunuzun çitine spreyle boyamayın (kibarca sormadan)!

Hack!
Bunu yap:

1. Oluşturmak sanal çevre:

$ sanalenv venv

ve etkinleştirin:

$ . venv/bin/etkinleştir

veya kullanım sanalenvwrapper sanal ortamınızı oluşturmak ve yönetmek için:

$ mkvirtualenv hy
$ çalışmak hy

2. Kaynak kodunu alın:

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

veya çatalınızı kullanın:

$ git klonu [e-posta korumalı]: /hy.git

3. Bilgisayar korsanlığı için yükleyin:

$ cd hy/
$ pip kurulumu -e .

4. Diğer geliştirme gereksinimlerini yükleyin:

$ pip kurulum -r gereksinimleri-dev.txt

5. Harika şeyler yapın; Yaptığınız şeye karşı birinin zevk/iğrenme çığlıkları atmasını sağlayın.

Testi!
Testler yer almaktadır testler /. Kullanırız burun.

Testleri çalıştırmak için:

$ burun testleri

Yazma testleri --- testler iyidir!

Ayrıca, desteklenen tüm platformlar ve PEP 8 uyumlu testler için testler yapmak iyidir.
kod. Tox çalıştırarak bunu yapabilirsiniz:

$ zehir

Belge!
Belgeler şurada bulunur: belgeler/. Kullanırız Sfenks.

Belgeleri HTML'de oluşturmak için:

$ cd belgeleri
$ html yapmak

Doküman yaz --- dokümanlar iyidir! Hatta bu doktor!

Katkıda
Katkılar memnuniyetle karşılanır ve çok takdir edilir, her küçük parça Hy'yi daha fazla yapmaya yardımcı olur
müthiş.

Çekme istekleri harika! Biz onları seviyoruz; İşte hızlı bir kılavuz:

· Depoyu çatallayın ve bir özellik/düzeltme için bir konu dalı oluşturun. Doğrudan değişiklik yapmaktan kaçının
ana dalda.

· Gelen tüm özelliklere testler eşlik etmelidir.

· Bir PR göndermeden önce, lütfen testleri çalıştırın ve kodunuzu stile göre kontrol edin.
kılavuz. Bu iki işlemi aynı anda yapabilirsiniz:

$ yapmak

· Daha sonra izlemeyi ve gezinmeyi kolaylaştırmak için taahhütleri mantıksal birimlere dönüştürün. Önceki
bir PR göndererek, taahhütleri geri gelmesi kolay değişiklik kümelerine sıkıştırmayı deneyin.
sonra. Ayrıca, değişiklik kümelerinde sahte boşluk bırakmadığınızdan emin olun; Bugün nasılsın
daha sonra boşluk düzeltme taahhütlerinin oluşturulmasını önler.

· Taahhüt mesajları söz konusu olduğunda, aşağıdakilere uymaya çalışın:

· Git taahhüt mesajlarının ilk satırı için 50 karakter sınırına bağlı kalmayı deneyin.

· Daha fazla detay/açıklama için bunu boş bir satır ile takip edin ve devam edin
taahhüdü ayrıntılı olarak açıklayan.

· Son olarak, kendinizi AUTHORS dosyasına ekleyin (ayrı bir taahhüt olarak): bunu hak ediyorsunuz :)

· Gelen tüm değişikliklerin Hylang'ın çekirdek ekibinin 2 farklı üyesi tarafından onaylanması gerekir.
Ek inceleme kesinlikle memnuniyetle karşılanır, ancak herhangi biri için en az 2 imzaya ihtiyacımız var.
değiştirin.

· Bir çekirdek üye bir PR gönderiyorsa, lütfen aşağıdakileri içermeyen 2 çekirdek üye bulun.
PR gönderen. Buradaki fikir, kişinin halkla ilişkiler yazarıyla çalışabilmesi ve ikincisinin kabul etmesidir.
tüm değişiklik seti.

· Belgeler ve diğer önemsiz değişiklikler için, bir ACK'den sonra birleştirmede fayda var. Biz sahibiz
düşük kapsama alanı, bu yüzden bu bariyeri düşük tutmak harika olurdu.

çekirdek Takımı
Hy'ın çekirdek geliştirme ekibi aşağıdaki geliştiricilerden oluşur:

· Julian Danjou

· Morten Linderud

· J Kenneth King

· Gergely Nagy

· Tuukka kaplumbağa

· Karen paslı

· Abhishek L

· Christopher Allan Webber

· Konrad Hinsen

· Will Kahn Greene

· Paul Tagliamonte

· nicolas Dandrimont

· şilin Tolbert'in

· Berker peksağ

· clinton N. Dreisbach

· o semaj

onworks.net hizmetlerini kullanarak hy çevrimiçi kullanın