hy - Dalam talian di Awan

JADUAL:

NAMA

hy - hy Dokumentasi [imej: Hy] [imej]

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

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

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

senarai hylang-bincang

IRC #hy pada Freenode

Membina terkini
Travis CI.UNINDENT

Hy ialah dialek Lisp yang indah yang tertanam dalam Python.

Memandangkan Hy menukar kod Lispnya menjadi Pokok Sintaks Abstrak Python, anda telah melakukannya
seluruh dunia Python yang indah di hujung jari anda, dalam bentuk Lisp!

Kandungan:

PERMULAAN PANTAS

[imej: Peluk Karen Rustard] [imej]

(Terima kasih kepada Karen Rustad untuk Pelukan!)

BAGAIMANA KEPADA GET HY REAL FAST:

1. Buat a Maya Python alam Sekitar.

2. Aktifkan Persekitaran Python Maya anda.

3. Memasang hy dari PyPI bersama pip memasang hy.

4. Mulakan REPL dengan hy.

5. Taip bahan dalam REPL:

=> (cetak "Hy!")
Hy!
=> (defn salutationsnm [nama] (cetak (+ "Hy " nama "!")))
=> (salutationsnm "Nama Anda")
HyNama Anda!

dan lain-lain

6. Tekan CTRL-D apabila anda selesai.

OMG! Itulah Menakjubkan! I mahu kepada menulis a Hy program.

7. Buka editor pengaturcaraan elit dan taip:

(cetak "Saya akan membuat kod dalam sintaks Python, tetapi kemudian saya mendapat Hy.")

8. Simpan sebagai hebat.hy.

9. Dan jalankan program Hy pertama anda:

hy hebat.hy

10.
Tarik nafas dalam-dalam supaya tidak mengalami hiperventilasi.

11.
Senyum jahat dan menyelinap ke tempat persembunyian anda dan lakukan perkara yang tidak terkata.

TUTORIAL

Selamat datang ke tutorial Hy!

Secara ringkasnya, Hy ialah dialek Lisp, tetapi dialek yang menukar strukturnya menjadi Python ...
benar-benar penukaran kepada pokok sintaks abstrak Python! (Atau untuk meletakkannya dalam lebih mentah
istilah, Hy adalah lisp-stick pada Python!)

Ini agak keren kerana ini bermakna Hy adalah beberapa perkara:

· Lisp yang terasa sangat Pythonic

· Untuk Lispers, cara terbaik untuk menggunakan kuasa gila Lisp tetapi dalam dunia Python yang luas
perpustakaan (mengapa ya, anda kini boleh menulis aplikasi Django dalam Lisp!)

· Untuk Pythonista, cara terbaik untuk mula meneroka Lisp, dari keselesaan Python!

· Untuk semua orang: bahasa yang menyenangkan yang mempunyai banyak idea yang kemas!

Asas intro kepada Pelat Untuk Pythonistas
Okay, mungkin anda tidak pernah menggunakan Lisp sebelum ini, tetapi anda pernah menggunakan Python!

Program "hello world" dalam Hy sebenarnya sangat mudah. Jom cuba:

(cetak "hello world")

Nampak? Mudah! Seperti yang anda mungkin telah meneka, ini adalah sama dengan versi Python:

cetak "hello dunia"

Untuk menambah beberapa matematik yang sangat mudah, kita boleh lakukan:

(+ 1 3)

Yang akan mengembalikan 4 dan akan bersamaan dengan:

1 + 3

Apa yang anda akan perhatikan ialah item pertama dalam senarai ialah fungsi yang dipanggil dan
selebihnya hujah adalah hujah yang diluluskan. Malah, dalam Hy (seperti kebanyakan
Lisps) kita boleh menyampaikan berbilang argumen kepada pengendali tambah:

(+ 1 3 55)

Yang akan mengembalikan 59.

Mungkin anda pernah mendengar tentang Lisp sebelum ini tetapi tidak tahu banyak tentangnya. Lisp tidak sekeras awak
mungkin berfikir, dan Hy mewarisi daripada Python, jadi Hy ialah cara terbaik untuk mula belajar Lisp.
Perkara utama yang jelas tentang Lisp ialah terdapat banyak kurungan. Ini mungkin
nampak mengelirukan pada mulanya, tetapi ia tidak begitu sukar. Mari kita lihat beberapa matematik mudah itu
dibungkus dalam sekumpulan kurungan yang boleh kita masukkan ke dalam penterjemah Hy:

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

Ini akan mengembalikan 38. Tetapi mengapa? Nah, kita boleh melihat ungkapan yang setara dalam
ular sawa:

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

Jika anda cuba memikirkan bagaimana perkara di atas berfungsi dalam python, anda sudah tentu akan
tentukan keputusan dengan menyelesaikan setiap kurungan dalaman. Itulah idea asas yang sama dalam
Hy. Mari cuba latihan ini dahulu dalam Python:

keputusan = ((1 + 3 + 88) / 2) - 8
# dipermudahkan kepada...
keputusan = (92/2) - 8
# dipermudahkan kepada...
keputusan = 46 - 8
# dipermudahkan kepada...
hasil = 38

Sekarang mari kita cuba perkara yang sama dalam Hy:

(hasil setv (- (/ (+ 1 3 88) 2) 8))
; dipermudahkan kepada...
(hasil setv (- (/ 92 2) 8))
; dipermudahkan kepada...
(hasil setv (- 46 8))
; dipermudahkan kepada...
(hasil setv 38)

Seperti yang anda mungkin sangka, ungkapan terakhir ini dengan setv bermaksud untuk menetapkan pembolehubah
"hasil" kepada 38.

Nampak? Tidak terlalu keras!

Ini adalah premis asas Lisp. Lisp bermaksud "pemprosesan senarai"; ini bermakna bahawa
struktur program sebenarnya ialah senarai senarai. (Jika anda biasa dengan Python
senarai, bayangkan keseluruhan struktur yang sama seperti di atas tetapi sebaliknya dengan kurungan persegi, mana-mana
anda akan dapat melihat struktur di atas sebagai program dan juga struktur data.) Ini adalah
lebih mudah difahami dengan lebih banyak contoh, jadi mari kita tulis program Python yang mudah, ujinya,
dan kemudian tunjukkan program Hy yang setara:

def simple_conversation():
print "Hello! Saya ingin berkenalan dengan anda. Beritahu saya tentang diri anda!"
name = raw_input("Siapa nama awak? ")
umur = raw_input("Berapa umur anda? ")
cetak "Hello " + nama + "! Saya nampak anda berumur " + umur + " tahun."

simple_conversation()

Jika kami menjalankan program ini, ia mungkin seperti:

hello! Saya ingin berkenalan dengan awak. Beritahu saya tentang diri anda!
siapa nama awak Gary
Berapakah umur anda? 38
Hello Gary! Saya lihat awak berumur 38 tahun.

Sekarang mari kita lihat program Hy yang setara:

(defn perbualan mudah []
(cetak "Helo! Saya ingin berkenalan dengan anda. Beritahu saya tentang diri anda!")
(nama setv (input mentah "Siapa nama anda?"))
(umur setv (input mentah "Berapa umur anda?"))
(cetak (+ "Hello " nama "! Saya nampak awak "
umur "tahun.")))

(perbualan ringkas)

Jika anda melihat program di atas, selagi anda ingat bahawa elemen pertama dalam setiap
senarai program ialah fungsi (atau makro... kita akan sampai kepada mereka kemudian) dipanggil
dan selebihnya adalah hujah, agak mudah untuk mengetahui maksud semua ini.
(Seperti yang anda mungkin juga meneka, defn ialah kaedah Hy untuk mentakrifkan kaedah.)

Namun, ramai orang mendapati perkara ini mengelirukan pada mulanya kerana terdapat banyak kurungan,
tetapi terdapat banyak perkara yang boleh membantu menjadikan ini lebih mudah: pastikan lekukan bagus dan
gunakan editor dengan padanan kurungan (ini akan membantu anda mengetahui perkara masing-masing
kurungan berpasangan dengan) dan perkara akan mula berasa selesa.

Terdapat beberapa kelebihan untuk mempunyai struktur kod yang sebenarnya merupakan data yang sangat mudah
struktur sebagai teras Lisp adalah berdasarkan. Untuk satu perkara, ini bermakna bahawa program anda adalah
mudah dihuraikan dan keseluruhan struktur sebenar program didedahkan dengan jelas
kepada awak. (Terdapat langkah tambahan dalam hy di mana struktur yang anda lihat ditukar kepada Python's
perwakilan sendiri ... dalam Lisps "lebih tulen" seperti Common Lisp atau Emacs Lisp, data
struktur yang anda lihat dalam kod dan struktur data yang dilaksanakan adalah lebih banyak lagi
betul-betul dekat.)

Satu lagi implikasi daripada ini ialah makro: jika struktur program ialah data mudah
struktur, ini bermakna anda boleh menulis kod yang boleh menulis kod dengan sangat mudah, bermakna itu
melaksanakan ciri bahasa yang sepenuhnya baharu boleh menjadi sangat pantas. Sebelum Hy, ini bukan
sangat mungkin untuk pengaturcara Python ... kini anda juga boleh menggunakan makro yang luar biasa
kuasa (hanya berhati-hati untuk tidak membidik mereka)!

Hy is a Berperisa lidah Python
Hy menukar kepada pepohon sintaks abstrak Python sendiri, jadi anda akan mula mencari semuanya
kuasa ular sawa yang biasa ada di hujung jari anda.

Anda mempunyai akses penuh kepada jenis data Python dan perpustakaan standard dalam Hy. Mari bereksperimen
dengan ini dalam penterjemah hy:

=> [1 2 3]
[1, 2, 3]
=> {"anjing" "kulit kayu"
... "kucing" "meow"}
...
{'anjing': 'kulit kayu', 'kucing': 'meow'}
=> (, 1 2 3)
(1, 2, 3)

Jika anda biasa dengan Lisps lain, anda mungkin berminat bahawa Hy menyokong Common
Kaedah memetik Lisp:

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

Anda juga mempunyai akses kepada semua kaedah bagus jenis terbina dalam:

=> (.jalur " fooooo ")
"fooooo"

Apakah ini? Ya memang, ini sama persis dengan:

" fooooo ".strip()

Betul---Lisp dengan notasi titik! Jika kita mempunyai rentetan ini ditetapkan sebagai pembolehubah, kita
juga boleh melakukan perkara berikut:

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

Bagaimana dengan syarat?:

(jika (cuba-sesuatu-perkara)
(cetak "ini jika benar")
(cetak "ini jika palsu"))

Seperti yang anda boleh beritahu di atas, hujah pertama untuk if adalah ujian kebenaran, hujah kedua ialah
isinya jika benar, dan hujah ketiga (pilihan!) adalah jika palsu (cth. lagi).

Jika anda perlu melakukan syarat yang lebih kompleks, anda akan mendapati bahawa anda tidak mempunyai elif
terdapat di Hy. Sebaliknya, anda harus menggunakan sesuatu yang dipanggil cond. Dalam Python, anda mungkin melakukannya
sesuatu seperti:

somevar = 33
jika somevar > 50:
cetak "Pembolehubah itu terlalu besar!"
elif somevar < 10:
cetak "Pembolehubah itu terlalu kecil!"
lain:
print "Pembolehubah itu adalah jussssst betul!"

Dalam Hy, anda akan lakukan:

(cond
[(> somevar 50)
(cetak "Pembolehubah itu terlalu besar!")]
[(< somevar 10)
(cetak "Pembolehubah itu terlalu kecil!")]
[benar
(cetak "Pembolehubah itu adalah jussssst betul!")])

Apa yang anda akan perhatikan ialah cond mematikan antara beberapa pernyataan yang dilaksanakan dan
diperiksa secara bersyarat untuk benar atau salah, dan kemudian sedikit kod untuk dilaksanakan jika ia bertukar
menjadi kenyataan. Anda juga akan perasan bahawa lagi dilaksanakan pada akhirnya hanya dengan
memeriksa untuk benar -- itu kerana benar akan sentiasa benar, jadi jika kita sampai sejauh ini, kita akan
selalu jalankan yang itu!

Anda mungkin perasan di atas bahawa jika anda mempunyai kod seperti:

(jika ada syarat
(badan-jika-benar)
(badan-jika-salah))

Tapi tunggu! Bagaimana jika anda ingin melaksanakan lebih daripada satu kenyataan dalam badan salah satu daripada
ini?

Anda boleh melakukan perkara berikut:

(jika (cuba-sesuatu-perkara)
(buat
(cetak "ini jika benar")
(cetak "dan mengapa tidak, mari kita terus bercakap tentang kebenarannya!))
(cetak "yang ini masih palsu semata-mata"))

Anda boleh lihat bahawa kami telah menggunakan do untuk membungkus berbilang kenyataan. Jika anda biasa dengan yang lain
Lisps, ini bersamaan dengan prog di tempat lain.

Komen bermula dengan koma bertitik:

(cetak "ini akan berjalan")
; (cetak "tetapi ini tidak akan")
(+ 1 2 3); kami akan melaksanakan penambahan, tetapi bukan ulasan ini!

Looping tidak keras tetapi mempunyai sejenis struktur khas. Dalam Python, kita mungkin melakukan:

untuk saya dalam pelbagai(10):
cetak "'i' kini berada di " + str(i)

Setara dalam Hy ialah:

(untuk [i (julat 10)]
(cetak (+ "'i' kini di " (str i))))

Anda juga boleh mengimport dan menggunakan pelbagai perpustakaan Python. Sebagai contoh:

(os import)

(jika (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/anotherdir")
(cetak "Hei, laluan itu tiada di sana!"))

Pengurus konteks Python (bersama pernyataan) digunakan seperti ini:

(dengan [[f (buka "/tmp/data.in")]]
(cetak (.baca f)))

yang bersamaan dengan:

dengan open("/tmp/data.in") sebagai f:
cetak f.read()

Dan ya, kami mempunyai pemahaman Senarai! Dalam Python anda mungkin lakukan:

odds_squared = [
pow(bilangan, 2)
untuk bilangan masuk pelbagai(100)
jika bilangan % 2 == 1]

Dalam Hy, anda boleh melakukan ini seperti:

(setv odds-squad
(senarai-komp
(pow nombor 2)
(bilangan (julat 100))
(= (% nombor 2) 1)))

; Dan, contoh yang dicuri tanpa segan silu dari halaman Clojure:
; Mari kita senaraikan semua blok Papan Catur:

(senarai-komp
(, xy)
(x (julat 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 mempunyai sokongan untuk pelbagai hujah mewah dan hujah kata kunci. Dalam Python kita mungkin
lihat:

>>> def optional_arg(pos1, pos2, keyword1=Tiada, keyword2=42):
... kembali [pos1, pos2, kata kunci1, kata kunci2]
...
>>> pilihan_arg(1, 2)
[1, 2, Tiada, 42]
>>> pilihan_arg(1, 2, 3, 4)
[1, 2, 3, 4]
>>> pilihan_arg(kata kunci1=1, pos2=2, pos1=3, kata kunci2=4)
[3, 2, 1, 4]

Perkara yang sama dalam Hy:

=> (defn optional-arg [pos1 pos2 &optional keyword1 [keyword2 42]]
... [pos1 pos2 kata kunci1 kata kunci2])
=> (pilihan-arg 1 2)
[1 2 Tiada 42]
=> (pilihan-arg 1 2 3 4)
[1 2 3 4]

Jika anda menjalankan versi Hy lepas 0.10.1 (cth, git master), terdapat juga versi baharu yang bagus
sintaks hujah kata kunci:

=> (optional-arg :keyword1 1
... :pos2 2
... :pos1 3
... :kata kunci2 4)
[3, 2, 1, 4]

Jika tidak, anda sentiasa boleh menggunakan memohon. Tetapi apa memohon?

Adakah anda biasa dengan berlalu masuk *args and **kwargs dalam Python?:

>>> args = [1 2]
>>> kwargs = {"kata kunci2": 3
... "kata kunci1": 4}
>>> pilihan_arg(*args, **kwargs)

Kita boleh menghasilkan semula ini dengan memohon:

=> (setv args [1 2])
=> (setv kwargs {"kata kunci2" 3
... "kata kunci1" 4})
=> (gunakan pilihan-arg args kwargs)
[1, 2, 4, 3]

Terdapat juga pembinaan hujah kata kunci gaya kamus yang kelihatan seperti:

(defn gaya lain [&key {"key1" "val1" "key2" "val2"}]
[kunci1 kunci2])

Perbezaan di sini ialah kerana ia adalah kamus, anda tidak boleh bergantung pada mana-mana yang khusus
memerintahkan kepada hujah.

Hy pun sokong *args and **kwargs. Dalam Python:

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

Setara Hy:

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

Akhirnya, sudah tentu kita memerlukan kelas! Dalam Python, kita mungkin mempunyai kelas seperti:

kelas FooBar(objek):
"" "
Satu Lagi Kelas Contoh
"" "
def __init__(diri, x):
diri.x = x

def get_x(self):
"" "
Kembalikan salinan x kami
"" "
kembali diri.x

Dalam Hy:

(defclass FooBar [objek]
"Kelas Contoh Lagi"
[[--di dalamnya--
(fn [diri x]
(setv self.xx)
; Pada masa ini diperlukan untuk --init-- kerana __init__ memerlukan Tiada
; Semoga ini akan hilang :)
Tiada)]

[dapat-x
(fn [diri]
"Kembalikan salinan x kami"
diri.x)]])

Anda juga boleh melakukan atribut peringkat kelas. Dalam Python:

Pelanggan kelas(model.Model):
nama = model.CharField(panjang_maks=255)
alamat = models.TextField()
nota = models.TextField()

Dalam Hy:

(defclass Pelanggan [models.Model]
[[nama (models.CharField :max-panjang 255})]
[alamat (models.TextField)]
[nota (model.TextField)]])

Hy <-> Python interop
Dengan mengimport Hy, anda boleh menggunakan Hy terus daripada Python!

Jika anda menyimpan yang berikut dalam salam.hy:

(defn salam [nama] (cetak "hello from hy," name))

Kemudian anda boleh menggunakannya terus dari python, dengan mengimport hy sebelum mengimport modul. Dalam
Ular sawa:

import hy
salam import

greetings.greet("Foo")

Anda juga boleh mengisytiharkan fungsi dalam python (atau malah kelas!) dan menggunakannya dalam Hy!

Jika anda menyimpan yang berikut dalam salam.py di Python:

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

Anda boleh menggunakannya dalam Hy:

(salam import)
(.salam salam "foo")

Untuk menggunakan hujah kata kunci, anda boleh gunakan dalam salam.py:

def greet(nama, tajuk="Tuan"):
print("Salam, %s %s" % (tajuk, nama))

(salam import)
(.salam salam "Foo")
(.salam salam "Foo" "Darth")
(mohon (. salam memberi salam) ["Foo"] {"title" "Lord"})

Yang akan menghasilkan:

Salam, Tuan Foo

Salam, Darth Foo

Salam, Tuan Foo

Protips!
Hy juga menampilkan sesuatu yang dikenali sebagai "makro benang", ciri yang sangat kemas
Clojure's. "makro threading" (ditulis sebagai ->) digunakan untuk mengelakkan sarang dalam
ungkapan.

Makro threading memasukkan setiap ungkapan ke dalam argumen pertama ungkapan seterusnya
tempat.

Mari kita ambil yang klasik:

(gelung (cetak (eval (baca))))

Daripada menulisnya seperti itu, kita boleh menulisnya seperti berikut:

(-> (baca) (eval) (cetak) (gelung))

Sekarang, menggunakan python-sh, kita boleh menunjukkan bagaimana makro threading (kerana persediaan python-sh)
boleh digunakan seperti paip:

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

Yang, sudah tentu, berkembang kepada:

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

Lebih mudah dibaca, bukan? Gunakan makro benang!

HY STYLE PANDUAN

“Anda tahu, Menteri, saya tidak bersetuju dengan Dumbledore dalam banyak perkara…tetapi anda tidak boleh menafikan dia
ada gaya…” — Phineas Nigellus Black, Harry Potter and yang order of yang Phoenix

Panduan gaya Hy berhasrat untuk menjadi satu set peraturan asas untuk Hyve (ya, komuniti Hy
berbangga dengan menambahkan Hy kepada segala-galanya) untuk menulis kod Hy idiomatik. Hy memperoleh banyak
daripada Clojure & Common Lisp, sambil sentiasa mengekalkan kebolehoperasian Python.

Permulaan
. KUCING of Hy
Ummon bertanya kepada ketua rahib itu, "Sutra apa yang kamu syarahan?"
"Sutra Nirvana."
"Sutra Nirvana mempunyai Empat Kebajikan, bukan?"
"Ia mempunyai."
Ummon bertanya sambil mengambil cawan, "Berapa banyak kebaikan ini?"
"Tiada sama sekali," kata bhikkhu itu.
"Tetapi orang purba berkata ia ada, bukan?" kata Ummon.
"Apa pendapat anda tentang apa yang mereka katakan?"
Ummon memukul cawan dan bertanya, "Anda faham?"
"Tidak," kata bhikkhu itu.
"Kalau begitu," kata Ummon, "Lebih baik kamu teruskan ceramah kamu tentang sutra."
- makro (koan).

Yang berikut menggambarkan senarai ringkas keputusan reka bentuk yang dibuat
Hy.

· Kelihatan seperti Lisp; DTRT dengannya (cth sengkang bertukar kepada garis bawah, penutup telinga bertukar kepada
bertopi semua).

· Kami masih Python. Kebanyakan bahagian dalaman menterjemahkan 1:1 kepada dalaman Python.

· Gunakan Unicode di mana-mana sahaja.

· Betulkan keputusan buruk dalam Python 2 apabila kita boleh (lihat pembahagian_benar).

· Apabila ragu-ragu, tunda kepada Python.

· Jika anda masih tidak pasti, tunda kepada Clojure.

· Jika anda lebih tidak pasti, tunda kepada Common Lisp.

· Perlu diingat kami bukan Clojure. Kami bukan Common Lisp. Kami Homoiconic Python, dengan
bit tambahan yang masuk akal.

Susun atur & Indentasi
· Elakkan ruang mengekor. Mereka menyebalkan!

· Lekukan hendaklah 2 ruang (tiada tab keras), kecuali apabila memadankan lekukan
baris sebelumnya.

;; Baik (dan diutamakan)
(defn fib [n]
(jika (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Masih okay
(defn fib [n]
(jika (<= n 2) n (+ (fib (- n 1)) (fib (- n 2)))))

;; Masih okay
(defn fib [n]
(jika (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Hysterically mengarut
(defn fib [n]
(jika (<= n 2)
n ;; ya, saya suka menekan kekunci ruang secara rawak
(+ (fib (- n 1)) (fib (- n 2)))))

· Tanda kurung mestilah pernah dibiarkan bersendirian, sedih dan sunyi di talian sendiri.

;; Baik (dan diutamakan)
(defn fib [n]
(jika (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Hysterically mengarut
(defn fib [n]
(jika (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))
)
); GAH, BAKARLAH DENGAN API

· Jajar secara menegak biarkan Blok.

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

· Komen sebaris hendaklah dua ruang dari hujung kod; mereka mesti sentiasa mempunyai a
ruang antara watak komen dan permulaan ulasan. Juga, cuba untuk tidak
komen yang jelas.

;; Baik
(setv ind (dec x)); pengindeksan bermula dari 0

;; Mematuhi gaya tetapi hanya menyatakan yang jelas
(setv ind (dec x)); menetapkan indeks kepada x-1

;; teruk
(setv ind (dec x));menaip perkataan untuk keseronokan

Pengekodan Style
· Sebagai konvensyen, cuba jangan gunakan def untuk apa-apa selain pembolehubah global; guna setv
fungsi dalam, gelung, dsb.

;; Baik (dan diutamakan)
(def *had* 400000)

(defn fibs [ab]
(sedangkan benar
(hasil a)
(setv (, ab) (, b (+ ab)))))

;; Buruk (dan tidak diutamakan)
(defn fibs [ab]
(sedangkan benar
(hasil a)
(def (, ab) (, b (+ ab)))))

· Jangan gunakan sintaks ungkapan-s yang dimaksudkan dengan sintaks vektor. Sebagai contoh, fakta
bahawa bekas kedua-dua contoh ini berfungsi hanya kerana pengkompil tidak terlalu banyak
tegas. Pada hakikatnya, sintaks yang betul di tempat seperti ini adalah yang terakhir.

;; Buruk (dan jahat)
(defn foo (x) (cetak x))
(foo 1)

;; Baik (dan diutamakan)
(defn foo [x] (cetak x))
(foo 1)

· Gunakan makro benang atau makro ekor benang apabila menemui bersarang dalam
s-ungkapan. Walau bagaimanapun, berhati-hati apabila menggunakannya. Gunakannya apabila kejelasan dan
kebolehbacaan bertambah baik; jangan membina ungkapan yang berbelit-belit, sukar difahami.

;; Diutamakan
(def *nama*
(dengan [f (buka "nama.txt")]
(-> (.baca f) (.strip) (.gantikan "\"" "") (.split ","") (diisih))))

;; Tidak begitu bagus
(def *nama*
(dengan [f (buka "nama.txt")]
(diisih (.split "," (.replace "\"" "" (.strip (.read f)))))))

;; Mungkin bukan idea yang baik
(defn persegi? [x]
(->> 2 (pow (int (sqrt x))) (= x)))

· Notasi titik gaya Clojure diutamakan berbanding panggilan langsung kaedah objek,
walaupun kedua-duanya akan terus disokong.

;; Baik
(dengan [fd (buka "/ etc / passwd")]
(cetak (.readlines fd)))

;; Tidak begitu bagus
(dengan [fd (buka "/ etc / passwd")]
(cetak (fd.readlines)))

Kesimpulan
“Fesyen pudar, gaya kekal” —Yves Saint Laurent

Panduan ini hanyalah satu set garis panduan komuniti, dan jelas sekali, garis panduan komuniti melakukannya
tidak masuk akal tanpa komuniti yang aktif. Sumbangan dialu-alukan. Sertai kami di #hy in
freenode, blog tentangnya, tweet tentangnya, dan yang paling penting, berseronok dengan Hy.

Terima kasih
· Panduan ini banyak diilhamkan daripada @paultag catatan blog Hy Survival Panduan

· The Clojure Style Panduan

DOKUMENTASI INDEKS

Kandungan:

Perintah Talian Antara muka
hy
Perintah Talian Pilihan
-c
Jalankan kod Hy dalam arahan.

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

-i
Jalankan kod Hy dalam arahan, kemudian tinggal di REPL.

-m
Jalankan kod Hy dalam modul, Termasuk defmain jika ditakrifkan.

. -m flag menamatkan senarai pilihan supaya semua hujah selepas modul nama
dihantar ke modul dalam sys.argv.

Baru dalam versi 0.10.2.

--pengintip Cetak kod Python setara sebelum melaksanakan. Sebagai contoh:

=> (defn salutationsnm [nama] (cetak (+ "Hy " nama "!")))
def salutationsnm(nama):
kembalikan cetakan(((u'Hy ' + nama) + u'!'))
=> (salutationsnm "Nama Anda")
salutationsnm(u'YourName')
HyNama Anda!
=>

Baru dalam versi 0.9.11.

--tunjukkan-jejak balik
Cetak jejak balik lanjutan untuk pengecualian Hy.

Baru dalam versi 0.9.12.

-v Cetak nombor versi Hy dan keluar.

hyc
Perintah Talian Pilihan
fail [, failN]
Susun kod Hy kepada kod bait Python. Sebagai contoh, simpan kod berikut sebagai
hyname.hy:

(defn hy-hy [nama]
(cetak (+ "Hy " nama "!")))

(hy-hy "Afroman")

Kemudian jalankan:

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

hy2py
Baru dalam versi 0.10.1.

Perintah Talian Pilihan
-s

--dengan-sumber
Tunjukkan struktur sumber yang dihuraikan.

-a

--dengan-ast
Tunjukkan AST yang dijana.

-np

--tanpa-python
Jangan tunjukkan kod Python yang dijana daripada AST.

Hy (Yang bahasa)
AMARAN :
Ini tidak lengkap; sila pertimbangkan untuk menyumbang kepada usaha dokumentasi.

Teori of Hy
Hy mengekalkan, berbanding segala-galanya, 100% keserasian dalam kedua-dua arah dengan Python
sendiri. Semua kod Hy mengikut beberapa peraturan mudah. Hafal ini, kerana ia akan masuk
berguna.

Peraturan ini membantu memastikan bahawa kod Hy adalah idiomatik dan boleh antara muka dalam kedua-dua bahasa.

· Simbol dalam penutup telinga akan diterjemahkan kepada versi huruf besar rentetan itu. Untuk
contohnya, foo akan menjadi FOO.

· Entiti UTF-8 akan dikodkan menggunakan punkod dan diawali dengan hy_. Contohnya, ⚘
akan menjadi hy_w7h, ♥ akan menjadi hy_g6h, dan saya♥u akan menjadi hy_iu_t0x.

· Simbol yang mengandungi sempang akan digantikan dengan garis bawah. Sebagai contoh,
render-template akan menjadi render_template. Ini bermakna bahawa simbol dengan sempang akan
membayangi persamaan garis bawah mereka, dan sebaliknya.

Terbina Dalam
Hy menampilkan beberapa bentuk khas yang digunakan untuk membantu menjana Python AST yang betul.
Berikut ialah borang "istimewa", yang mungkin mempunyai tingkah laku yang agak tidak dijangka
beberapa situasi.

.
Baru dalam versi 0.10.0.

. digunakan untuk melaksanakan capaian atribut pada objek. Ia menggunakan DSL kecil untuk membolehkan pantas
akses kepada atribut dan item dalam struktur data bersarang.

Sebagai contoh,

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

Menyusun ke:

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

. menyusun hujah pertamanya (dalam contoh, foo) sebagai objek untuk melakukan
kekurangan rujukan. Ia menggunakan simbol kosong sebagai atribut untuk mengakses (dalam contoh, bar,
asas, frob), dan menyusun kandungan senarai (dalam contoh, [(+ 1 2)]) untuk pengindeksan.
Argumen lain membuang ralat kompilasi.

Akses kepada atribut yang tidak diketahui membuang an AttributeError. Akses kepada kunci yang tidak diketahui membuang an
Kesalahan Indeks (pada senarai dan tupel) atau a Kesalahan Utama (pada kamus).

->
-> (Atau menjalar makro) digunakan untuk mengelakkan ekspresi bersarang. Makro benang
memasukkan setiap ungkapan ke tempat hujah pertama ungkapan seterusnya. Yang berikut
kod menunjukkan ini:

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

- >>
- >> (Atau menjalar ekor makro) adalah serupa dengan menjalar makro, tetapi sebaliknya
memasukkan setiap ungkapan ke dalam hujah pertama ungkapan seterusnya, ia menambahkannya sebagai
hujah terakhir. Kod berikut menunjukkan ini:

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

memohon
memohon digunakan untuk menggunakan senarai pilihan hujah dan kamus pilihan kwarg
kepada sesuatu fungsi.

Penggunaan: (mohon nama-fn [args] [kwargs])

Contoh:

(defn rasa []
"hai di sana")

(gunakan thunk)
; => "hai di sana"

(defn jumlah pembelian [jumlah harga & pilihan [yuran 1.05] [vat 1.1]]
(* amaun harga yuran vat))

(gunakan jumlah pembelian [10 15])
; => 173.25

(gunakan jumlah pembelian [10 15] {"vat" 1.05})
; => 165.375

(gunakan jumlah pembelian [] {"harga" 10 "jumlah" 15 "vat" 1.05})
; => 165.375

and
and digunakan dalam ungkapan logik. Ia memerlukan sekurang-kurangnya dua parameter. Jika semua parameter
menilai ke Benar, parameter terakhir dikembalikan. Dalam mana-mana kes lain, nilai palsu pertama
akan dikembalikan. Contoh penggunaan:

=> (dan Betul Salah)
Palsu

=> (dan Benar Benar)
Benar

=> (dan Benar 1)
1

=> (dan Betul [] Salah Betul)
[]

PERHATIAN:
and litar pintas dan berhenti menilai parameter sebaik sahaja yang pertama palsu
berjumpa.

=> (dan Salah (cetak "hello"))
Palsu

menegaskan
menegaskan digunakan untuk mengesahkan keadaan semasa program sedang berjalan. Jika syaratnya tidak
bertemu, an AssertionError dinaikkan. menegaskan mungkin mengambil satu atau dua parameter. Yang pertama
parameter ialah syarat untuk diperiksa, dan ia harus menilai sama ada Benar or Palsu. Yang
parameter kedua, pilihan, ialah label untuk penegasan, dan merupakan rentetan yang akan
dibesarkan dengan AssertionError. Sebagai contoh:

(tegaskan (= nilai jangkaan berubah))

(tegaskan Salah)
; AssertionError

(tegaskan (= 1 2) "satu harus sama dengan dua")
; AssertionError: satu harus sama dengan dua

sekutu
sekutu digunakan untuk mengaitkan kunci dengan nilai dalam kamus atau untuk menetapkan indeks senarai
kepada suatu nilai. Ia memerlukan sekurang-kurangnya tiga parameter: data struktur untuk diubah suai, a utama
or indeks, Dan nilai. Jika lebih daripada tiga parameter digunakan, ia akan dikaitkan secara berpasangan.

Contoh penggunaan:

=>(biarkan [[koleksi {}]]
... (koleksi bersekutu "Anjing" "Bark")
... (koleksi cetakan))
{u'Dog': u'Bark'}

=>(biarkan [[koleksi {}]]
... (koleksi bersekutu "Anjing" "Bark" "Kucing" "Meow")
... (koleksi cetakan))
{u'Cat': u'Meow', u'Dog': u'Bark'}

=>(biarkan [[koleksi [1 2 3 4]]]
... (koleksi bersekutu 2 Tiada)
... (koleksi cetakan))
[1, 2, Tiada, 4]

PERHATIAN:
sekutu mengubah suai struktur data di tempat dan kembali Tiada.

memecahkan
memecahkan digunakan untuk keluar dari gelung. Ia menamatkan gelung serta-merta. Yang berikut
contoh mempunyai tak terhingga manakala gelung yang ditamatkan sebaik sahaja pengguna masuk k.

(sementara Benar (jika (= "k" (input mentah "? "))
(rehat)
(cetak "Cuba lagi")))

cond
cond boleh digunakan untuk membina bersarang if kenyataan. Contoh berikut menunjukkan
hubungan antara makro dan pengembangannya:

(cond [condition-1 result-1]
[syarat-2 keputusan-2])

(jika keadaan-1 hasil-1
(jika keadaan-2 hasil-2))

Seperti yang ditunjukkan di bawah, hanya blok hasil padanan pertama dilaksanakan.

=> (nilai semak defn [nilai]
... (cond [(< nilai 5) (cetak "nilai lebih kecil daripada 5")]
... [(= nilai 5) (cetak "nilai bersamaan dengan 5")]
... [(> nilai 5) (cetak "nilai lebih besar daripada 5")]
... [Benar (cetak "nilai ialah sesuatu yang tidak sepatutnya")]))

=> (nilai semak 6)
nilai lebih besar daripada 5

terus
terus mengembalikan pelaksanaan kepada permulaan gelung. Dalam contoh berikut,
(kesan sampingan1) dipanggil untuk setiap lelaran. (kesan sampingan2), bagaimanapun, hanya dipanggil
setiap nilai lain dalam senarai.

;; dengan mengandaikan bahawa (kesan-sampingan1) dan (kesan-sampingan2) ialah fungsi dan
;; koleksi ialah senarai nilai berangka

(untuk [x koleksi]
(buat
(kesan sampingan1 x)
(jika (% x 2)
(sambung))
(kesan sampingan2 x)))

dict-comp
dict-comp digunakan untuk mencipta kamus. Ia memerlukan tiga atau empat parameter. Yang pertama
dua parameter adalah untuk mengawal nilai pulangan (pasangan nilai-kunci) manakala yang ketiga ialah
digunakan untuk memilih item daripada urutan. Parameter keempat dan pilihan boleh digunakan untuk
tapis beberapa item dalam urutan berdasarkan ungkapan bersyarat.

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

do / prog
do and prog digunakan untuk menilai setiap hujah mereka dan mengembalikan yang terakhir. Kembali
nilai daripada setiap lain daripada hujah terakhir dibuang. Ia boleh digunakan dalam lambda or
senarai-komp untuk melaksanakan logik yang lebih kompleks seperti yang ditunjukkan dalam salah satu contoh berikut.

Beberapa contoh penggunaan:

=> (jika benar
... (buat (cetak "Kesan sampingan batu!")
... (cetak "Ya, betul-betul!")))
Kesan sampingan rock!
Ya, sungguh!

;; dengan mengandaikan bahawa (kesan sampingan) adalah fungsi yang ingin kita panggil untuk setiap satu
;; dan setiap nilai dalam senarai, tetapi nilai pulangannya tidak kami pedulikan
=> (list-comp (buat (kesan sampingan x))
... (jika (< x 5) (* 2 x)
... (* 4 x)))
... (x (julat 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do boleh menerima sebarang bilangan hujah, dari 1 hingga n.

def / setv
def and setv digunakan untuk mengikat nilai, objek atau fungsi kepada simbol. Sebagai contoh:

=> (def nama ["Alice" "Bob" "Charlie"])
=> (cetak nama)
[u'Alice', u'Bob', u'Charlie']

=> (kaunter setv (fn [item koleksi] (.kira item koleksi)))
=> (kaunter [1 2 3 4 5 2 3] 2)
2

defclass
Kelas baharu diisytiharkan dengan defclass. Ia boleh mengambil dua parameter pilihan: vektor
mentakrifkan kelas super yang mungkin dan vektor lain yang mengandungi atribut baru
kelas sebagai dua vektor item.

(defclass class-name [super-class-1 super-class-2]
[[nilai atribut]])

Kedua-dua nilai dan fungsi boleh terikat pada kelas baharu seperti yang ditunjukkan oleh contoh di bawah:

=> (defclass Cat []
... [[umur Tiada]
... [warna "putih"]
... [cakap (fn [diri] (cetak "Meow"))]])

=> (def spot (Kucing))
=> (setv spot.colour "Hitam")
'Hitam'
=> (.speak spot)
Meow

defn / defun
defn and defun makro digunakan untuk menentukan fungsi. Mereka mengambil tiga parameter: yang nama
daripada fungsi untuk mentakrifkan, vektor bagi parameter, Dan badan daripada fungsi:

(nama defn [params] badan)

Parameter mungkin mempunyai kata kunci berikut di hadapannya:

&pilihan
Parameter adalah pilihan. Parameter boleh diberikan sebagai senarai dua item, di mana
elemen pertama ialah nama parameter dan yang kedua ialah nilai lalai. Parameter
boleh juga diberikan sebagai satu item, dalam hal ini nilai lalai adalah Tiada.

=> (defn jumlah-nilai [nilai &pilihan [nilai-tambah-cukai 10]]
... (+ (/ (* nilai nilai tambah-cukai) 100) nilai))

=> (jumlah nilai 100)
110.0

=> (jumlah nilai 100 1)
101.0

&kunci

&kwargs
Parameter akan mengandungi 0 atau lebih argumen kata kunci.

Contoh kod berikut mentakrifkan fungsi yang akan mencetak semua kata kunci
hujah dan nilainya.

=> (defn print-parameters [&kwargs kwargs]
... (untuk [(, kv) (.item kwarg)] (cetak kv)))

=> (gunakan parameter-cetak [] {"parameter-1" 1 "parameter-2" 2})
parameter-2 2
parameter-1 1

&rehat Parameter akan mengandungi 0 atau lebih argumen kedudukan. Tiada kedudukan lain
hujah boleh ditentukan selepas ini.

Contoh kod berikut mentakrifkan fungsi yang boleh diberikan 0 hingga n berangka
parameter. Ia kemudian menjumlahkan setiap nombor ganjil dan menolak setiap nombor genap.

=> (defn zig-zag-sum [&nombor rehat]
(biar [[nombor ganjil (komp senarai x [nombor x] (nombor ganjil? x))]
[nombor genap (komp senarai x [nombor x] (nombor genap? x))]]
(- (jumlah ganjil-nombor) (jumlah genap-nombor))))

=> (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
Baru dalam versi 0.10.0.

. defn-alias and defun-alias makro adalah seperti defn, dengan perbezaan yang
daripada mentakrifkan fungsi dengan satu nama, ini juga boleh menentukan alias. Lain-lain
daripada mengambil senarai simbol untuk nama fungsi sebagai parameter pertama, defn-alias and
defun-alias tidak berbeza dengan defn and defun.

=> (defn-alias [nama-nama alias] []
... (cetak "Hello!"))
=> (nama utama)
"Hello!"
=> (alias)
"Hello!"

defmain
Baru dalam versi 0.10.1.

. defmain makro mentakrifkan fungsi utama yang segera dipanggil dengan sys.argv as
argumen jika dan hanya jika fail ini dilaksanakan sebagai skrip. Dengan kata lain, ini:

(defmain [&rest args]
(buat-sesuatu-dengan args))

adalah bersamaan dengan:

def utama(*args):
buat_sesuatu_dengan(args)
kembali 0

jika __nama__ == "__utama__":
import sys
retval = utama(*sys.arg)

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

Ambil perhatian bahawa seperti yang anda boleh lihat di atas, jika anda mengembalikan integer daripada fungsi ini, ini akan menjadi
digunakan sebagai status keluar untuk skrip anda. (Python lalai untuk keluar dari status 0 jika tidak,
yang bermaksud semuanya baik-baik saja!)

(Sejak (sys.exit 0) tidak dijalankan secara eksplisit dalam kes pulangan bukan integer daripada
defmain, ia adalah idea yang baik untuk meletakkan (defmain) sebagai sekeping kod terakhir dalam fail anda.)

defmakro
defmakro digunakan untuk menentukan makro. Format umum ialah (defmacro nama [parameter]
expr).

Contoh berikut mentakrifkan makro yang boleh digunakan untuk menukar susunan elemen dalam kod,
membenarkan pengguna menulis kod dalam notasi infix, di mana operator berada di antara
operan.

=> (defmacro infix [kod]
... (petikan kuasi (
... (nyah sebut harga (dapatkan kod 1))
... (nyah sebut harga (dapatkan kod 0))
... (nyah sebut harga (dapatkan kod 2)))))

=> (infiks (1 + 1))
2

defmakro-alias
defmakro-alias digunakan untuk menentukan makro dengan berbilang nama (alias). Format umum
is (defmacro-alias [nama] [parameter] expr). Ia mencipta berbilang makro dengan yang sama
senarai parameter dan badan, di bawah senarai nama yang ditentukan.

Contoh berikut mentakrifkan dua makro, kedua-duanya membenarkan pengguna menulis kod dalam
notasi infiks.

=> (defmacro-alias [infix infi] [kod]
... (petikan kuasi (
... (nyah sebut harga (dapatkan kod 1))
... (nyah sebut harga (dapatkan kod 0))
... (nyah sebut harga (dapatkan kod 2)))))

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

defmakro/g!
Baru dalam versi 0.9.12.

defmakro/g! ialah versi khas daripada defmakro yang digunakan untuk menjana secara automatik gensym
untuk sebarang simbol yang bermula dengan g!.

Sebagai contoh, g!a akan menjadi (gensym "a").

SEE JUGA:
Bahagian menggunakan-gensym

defreader
Baru dalam versi 0.9.12.

defreader mentakrifkan makro pembaca, membolehkan anda menyusun semula atau mengubah suai sintaks.

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

SEE JUGA:
Makro Pembaca Bahagian

yang
Baru dalam versi 0.9.12.

yang mengalih keluar objek daripada ruang nama semasa.

=> (setv foo 42)
=> (del foo)
=> foo
Jejak balik (panggilan terakhir terakhir):
Fail " ", baris 1, dalam
NameError: nama 'foo' tidak ditakrifkan

yang juga boleh mengalih keluar objek daripada pemetaan, senarai dan banyak lagi.

=> (ujian setv (senarai (julat 10)))
=> ujian
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (del (ujian kepingan 2 4)) ;; alih keluar item daripada 2 hingga 4 dikecualikan
=> ujian
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "bar"})
=> dic
{"foo": "bar"}
=> (del (dapatkan dic "foo"))
=> dic
{}

berbakat
Baru dalam versi 0.10.1.

berbakat digunakan untuk memudahkan urutan panggilan kaedah kepada objek.

=> (doto [] (.tambah 1) (.tambah 2) .balikkan)
[2 1]

=> (koleksi setv [])
=> (.tambah koleksi 1)
=> (.tambah koleksi 2)
=> (. koleksi terbalik)
=> koleksi
[2 1]

menipu
menipu menilai ungkapan yang disebut dan mengembalikan nilai.

=> (eval '(cetak "Hello World"))
"Hai dunia"

eval-and-compile
eval-apabila-compile
pertama / kereta
pertama and kereta adalah makro untuk mengakses elemen pertama koleksi:

=> (pertama (julat 10))
0

Untuk
Untuk digunakan untuk memanggil fungsi bagi setiap elemen dalam senarai atau vektor. Hasil setiap
panggilan dibuang dan Untuk ungkapan kembali Tiada sebaliknya. Kod contoh berulang
lebih koleksi dan untuk setiap satu elemen in koleksi memanggil kesan sampingan berfungsi dengan
elemen sebagai hujahnya:

;; dengan mengandaikan bahawa (kesan sampingan) ialah fungsi yang mengambil satu parameter
(untuk [koleksi elemen] (elemen kesan sampingan))

;; kerana boleh mempunyai blok lain pilihan
(untuk [koleksi elemen] (elemen kesan sampingan)
(lain (kesan sampingan-2)))

Pilihannya lagi blok hanya dilaksanakan jika Untuk gelung tamat seperti biasa. Sekiranya
pelaksanaan dihentikan dengan memecahkan, yang lagi blok tidak dilaksanakan.

=> (untuk [elemen [1 2 3]] (jika (< elemen 3)
... (elemen cetakan)
... (rehat))
... (lain (cetak "gelung selesai")))
1
2

=> (untuk [elemen [1 2 3]] (jika (< elemen 4)
... (elemen cetakan)
... (rehat))
... (lain (cetak "gelung selesai")))
1
2
3
gelung selesai

genexpr
genexpr digunakan untuk mencipta ungkapan penjana. Ia memerlukan dua atau tiga parameter. The
parameter pertama ialah ungkapan yang mengawal nilai pulangan, manakala yang kedua digunakan
untuk memilih item daripada senarai. Parameter ketiga dan pilihan boleh digunakan untuk menapis keluar
beberapa item dalam senarai berdasarkan ungkapan bersyarat. genexpr adalah sama dengan
senarai-komp, kecuali ia mengembalikan lelaran yang menilai nilai satu demi satu dan bukannya
menilai mereka dengan segera.

=> (koleksi def (julat 10))
=> (def ditapis (genexpr x [x koleksi] (genap? x)))
=> (senarai ditapis)
[0, 2, 4, 6, 8]

gensym
Baru dalam versi 0.9.12.

gensym digunakan untuk menjana simbol unik yang membolehkan makro ditulis tanpa
pertembungan nama berubah secara tidak sengaja.

=> (gensym)
u':G_1235'

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

SEE JUGA:
Bahagian menggunakan-gensym

mendapatkan
mendapatkan digunakan untuk mengakses elemen tunggal dalam senarai dan kamus. mendapatkan mengambil dua parameter:
yang data struktur dan juga indeks or utama daripada item tersebut. Ia kemudian akan mengembalikan yang sepadan
nilai daripada kamus atau senarai. Contoh penggunaan:

=> (biarkan [[haiwan {"anjing" "menyalak" "kucing" "meow"}]
... [nombor ["sifar" "satu" "dua" "tiga"]]]
... (cetak (dapatkan haiwan "anjing"))
... (cetak (dapat nombor 2)))
menyalak
2

PERHATIAN:
mendapatkan menimbulkan KeyError jika kamus ditanya untuk kunci yang tidak wujud.

PERHATIAN:
mendapatkan menimbulkan IndexError jika senarai atau tuple ditanya untuk indeks yang kehabisan
sempadan.

global
global boleh digunakan untuk menandakan simbol sebagai global. Ini membolehkan pengaturcara menetapkan a
nilai kepada simbol global. Membaca simbol global tidak memerlukan global kata kunci --
hanya memberikannya sahaja.

Contoh berikut menunjukkan bagaimana simbol global a diberikan nilai dalam fungsi dan
kemudiannya dicetak dalam fungsi lain. Tanpa global kata kunci, fungsi kedua
akan membuang a NameError.

(defn set-a [nilai]
(global a)
(setv nilai))

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

(set-a 5)
(cetak-a)

if / jika tidak
Baharu dalam versi 0.10.0: jika-tidak

if digunakan untuk memilih kod secara bersyarat untuk dilaksanakan. Ia mesti mengandungi syarat
blok dan blok yang akan dilaksanakan jika blok keadaan menilai kepada Benar. Secara pilihan,
ia mungkin mengandungi blok akhir yang dilaksanakan sekiranya penilaian keadaan adalah
Palsu.

jika tidak adalah serupa, tetapi blok kedua akan dilaksanakan apabila keadaan gagal manakala
blok ketiga dan terakhir dilaksanakan apabila ujian berjaya -- tertib yang bertentangan dengan if.

Contoh penggunaan:

(jika (wang kiri? akaun)
(cetak "jom pergi membeli-belah")
(cetak "jom pergi dan bekerja"))

(jika-tidak (wang-tinggal? akaun)
(cetak "jom pergi kerja")
(cetak "jom pergi membeli-belah"))

Kejujuran Python dihormati. Tiada, Palsu, sifar sebarang jenis angka, urutan kosong,
dan kamus kosong dipertimbangkan Palsu; semua yang lain dipertimbangkan Benar.

lisp-jika / serat and cadel-jika-tidak / hidup-tidak
Baru dalam versi 0.10.0.

Baharu dalam versi 0.10.2: lisp-if-not / lif-not

Bagi mereka yang lebih suka Lispy if fasal, kita ada lisp-jika, Atau serat. ini hanyalah menganggap
Tiada / tiada menjadi palsu! Semua nilai Python "false-ish" lain dianggap benar.
Sebaliknya, kita ada cadel-jika-tidak and hidup-tidak selari dengan if and jika tidak yang terbalik
perbandingan itu.

=> (lisp-jika Benar "benar" "salah")
"benar"
=> (lisp-jika Salah "benar" "salah")
"benar"
=> (lisp-jika 0 "benar" "salah")
"benar"
=> (lisp-jika tiada "benar" "salah")
"salah"
=> (lisp-jika Tiada "benar" "palsu")
"salah"
=> (lisp-if-not nil "true" "false")
"benar"
=> (lisp-if-not Tiada "benar" "palsu")
"benar"
=> (lisp-if-not Palsu "benar" "palsu")
"salah"

; Setara tetapi lebih pendek
=> (kehidupan Benar "benar" "salah")
"benar"
=> (seumur hidup tiada "benar" "salah")
"salah"
=> (hidup-bukan Tiada "benar" "palsu")
"benar"

mengimport
mengimport digunakan untuk mengimport modul, seperti dalam Python. Terdapat beberapa cara itu mengimport boleh
digunakan.

;; Mengimport setiap modul ini
;;
;; Ular sawa:
;; import sys
;; import os.path
(import sys os.path)

;; Import daripada modul
;;
;; Python: daripada os.path import wujud, isdir, isfile
(import [os.path [wujud isdir isfile]])

;; Import dengan alias
;;
;; Python: import sys sebagai systest
(import [sys :as systest])

;; Anda boleh menyenaraikan seberapa banyak import yang anda suka daripada jenis yang berbeza.
(import [tests.resources [kwtest function-with-a-dash]]
[os.path [wujud isdir isfile]]
[sys:sebagai sistem])

;; Import semua fungsi modul ke dalam ruang nama semasa
(import [sys [*]])

lambda / fn
lambda and fn boleh digunakan untuk menentukan fungsi tanpa nama. Parameter adalah serupa dengan
defn: parameter pertama ialah vektor parameter dan selebihnya ialah badan bagi
fungsi. lambda mengembalikan fungsi baharu. Dalam contoh berikut, fungsi tanpa nama
ditakrifkan dan dihantar ke fungsi lain untuk menapis output.

=> (def orang [{:name "Alice" :umur 20}
... {:nama "Bob" :umur 25}
... {:nama "Charlie" :umur 50}
... {:nama "Dave" :umur 5}])

=> (defn paparan-orang [penapis orang]
... (untuk [orang orang] (jika (tapis orang) (cetak (:nama orang)))))

=> (orang paparan-orang (fn [orang] (< (:orang umur) 25)))
Alice
Dave

Sama seperti dalam definisi fungsi biasa, jika elemen pertama badan ialah rentetan, ia
berfungsi sebagai docstring. Ini berguna untuk memberikan docstring kaedah kelas.

=> (setv kali-tiga
... (fn [x]
... "Mendarabkan input dengan tiga dan mengembalikan hasilnya."
... (* x 3)))

Ini boleh disahkan melalui Python terbina dalam membantu fungsi:

=> (bantuan kali-tiga)
Bantuan pada fungsi times_three:

kali_tiga(x)
Mendarabkan input dengan tiga dan mengembalikan hasil
(TAMAT)

lepas
Baru dalam versi 0.10.2.

lepas boleh digunakan untuk mengakses elemen terakhir koleksi:

=> (terakhir [2 4 6])
6

biarkan
biarkan digunakan untuk mencipta pembolehubah berskop leksikal. Mereka dicipta pada permulaan
biarkan bentuk dan tidak lagi wujud selepas bentuk. Contoh berikut mempamerkan ini
tingkah laku:

=> (biarkan [[x 5]] (cetak x)
... (biarkan [[x 6]] (cetak x))
... (cetak x))
5
6
5

. biarkan makro mengambil dua parameter: menentukan vektor pembolehubah dan juga badan yang mendapat
dilaksanakan. pembolehubah ialah vektor di mana setiap elemen adalah sama ada pembolehubah tunggal atau vektor
mentakrifkan pasangan nilai berubah. Dalam kes pembolehubah tunggal, ia diberikan nilai
Tiada; jika tidak, nilai yang dibekalkan digunakan.

=> (biarkan [x [y 5]] (cetak xy))
Tiada 5

senarai-komp
senarai-komp melaksanakan pemahaman senarai. Ia memerlukan dua atau tiga parameter. Yang pertama
parameter ialah ungkapan yang mengawal nilai pulangan, manakala yang kedua digunakan untuk
pilih item daripada senarai. Parameter ketiga dan pilihan boleh digunakan untuk menapis beberapa
daripada item dalam senarai berdasarkan ungkapan bersyarat. Beberapa contoh:

=> (koleksi def (julat 10))
=> (list-comp x [x koleksi])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

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

tidak
tidak digunakan dalam ungkapan logik. Ia memerlukan satu parameter dan mengembalikan yang terbalik
nilai kebenaran. Jika Benar diberikan sebagai parameter, Palsu akan dikembalikan, begitu juga sebaliknya.
Contoh penggunaan:

=> (tidak Benar)
Palsu

=> (bukan Palsu)
Benar

=> (bukan Tiada)
Benar

or
or digunakan dalam ungkapan logik. Ia memerlukan sekurang-kurangnya dua parameter. Ia akan mengembalikan
parameter bukan palsu pertama. Jika tiada nilai sedemikian wujud, parameter terakhir akan dikembalikan.

=> (atau Betul Salah)
Benar

=> (dan False False)
Palsu

=> (dan Salah 1 Benar Salah)
1

PERHATIAN:
or litar pintas dan berhenti menilai parameter sebaik sahaja nilai sebenar pertama adalah
berjumpa.

=> (atau Benar (cetak "hello"))
Benar

cetak
cetak digunakan untuk mengeluarkan pada skrin. Contoh penggunaan:

(cetak "Hello dunia!")

PERHATIAN:
cetak sentiasa kembali Tiada.

quasiquote
quasiquote membolehkan anda memetik borang, tetapi juga menilai ungkapan secara selektif.
Ungkapan dalam a quasiquote boleh dinilai secara terpilih menggunakan unquote (~). The
borang yang dinilai juga boleh disambung menggunakan unquote-splice (~@). Quasiquote juga boleh
ditulis menggunakan petikan belakang (`) simbol.

;; biarkan `qux' menjadi pembolehubah dengan nilai (bar baz)
`(foo ~qux)
; bersamaan dengan '(foo (bar baz))
`(foo ~@qux)
; bersamaan dengan '(foo bar baz)

memetik
memetik mengembalikan borang yang diserahkan kepadanya tanpa menilainya. memetik boleh secara alternatif
ditulis menggunakan apostrof (') simbol.

=> (setv x '(cetak "Hello World"))
; pembolehubah x ditetapkan kepada ungkapan & tidak dinilai
=> x
(u'print' u'Hello World')
=> (eval x)
Hello World

memerlukan
memerlukan digunakan untuk mengimport makro daripada modul yang diberikan. Ia memerlukan sekurang-kurangnya satu parameter
menentukan modul yang makro harus diimport. Berbilang modul boleh diimport
dengan sebatang memerlukan.

Contoh berikut akan mengimport makro daripada modul-1 and modul-2:

(memerlukan modul-1 modul-2)

rehat / Cdr
rehat and Cdr kembalikan koleksi yang diluluskan sebagai hujah tanpa elemen pertama:

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

set-komp
set-komp digunakan untuk membuat set. Ia memerlukan dua atau tiga parameter. Parameter pertama ialah
untuk mengawal nilai pulangan, manakala yang kedua digunakan untuk memilih item daripada a
urutan. Parameter ketiga dan pilihan boleh digunakan untuk menapis beberapa item dalam
urutan berdasarkan ungkapan bersyarat.

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

keping
keping boleh digunakan untuk mengambil subset senarai dan membuat senarai baharu daripadanya. Borang
mengambil sekurang-kurangnya satu parameter yang menentukan senarai untuk dihiris. Dua parameter pilihan boleh
digunakan untuk memberikan kedudukan mula dan akhir subset. Jika mereka tidak dibekalkan, yang
nilai lalai bagi Tiada akan digunakan sebaliknya. Parameter pilihan ketiga digunakan untuk
langkah kawalan antara elemen.

keping mengikuti peraturan yang sama seperti rakan Pythonnya. Indeks negatif dikira
bermula dari akhir senarai. Beberapa contoh penggunaan:

=> (koleksi def (julat 10))

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

=> (koleksi keping 5)
[5, 6, 7, 8, 9]

=> (koleksi kepingan 2 8)
[2, 3, 4, 5, 6, 7]

=> (koleksi kepingan 2 8 2)
[2, 4, 6]

=> (koleksi kepingan -4 -2)
[6, 7]

membuang / meningkatkan
. membuang or meningkatkan borang boleh digunakan untuk menaikkan an Pengecualian pada masa larian. Contoh penggunaan:

(buang)
; padam semula pengecualian terakhir

(buang IOError)
; Lemparkan IOError

(buang (IOError "foobar"))
; Lemparkan IOError("foobar")

membuang boleh menerima satu hujah (an Pengecualian kelas atau contoh) atau tiada hujah untuk
bangkitkan semula yang terakhir Pengecualian.

cubalah
. cubalah borang digunakan untuk memulakan a cubalah / menangkap blok. Borang digunakan seperti berikut:

(cuba
(fungsi mudah ralat)
(tangkap [e ZeroDivisionError] (cetak "Bahagian dengan sifar"))
(lain (cetak "tiada ralat"))
(akhirnya (cetak "semua selesai")))

cubalah mesti mengandungi sekurang-kurangnya satu menangkap blok, dan boleh pilihan termasuk a lagi or akhirnya
blok. Jika ralat dibangkitkan dengan blok tangkapan yang sepadan semasa pelaksanaan
fungsi mudah ralat, Yang menangkap blok akan dilaksanakan. Jika tiada ralat ditimbulkan, lagi
blok dilaksanakan. The akhirnya blok akan dilaksanakan terakhir tanpa mengira sama ada an
ralat ditimbulkan.

melainkan jika
. melainkan jika makro ialah singkatan untuk menulis an if pernyataan yang menyemak sama ada yang diberikan
bersyarat ialah Palsu. Berikut menunjukkan pengembangan makro ini.

(kecuali pernyataan bersyarat)

(jika bersyarat
Tiada
(buat kenyataan))

unquote
Dalam bentuk kuasiquoted, unquote memaksa penilaian simbol. unquote adalah alias kepada
tilde (~) simbol.

(nama def "Peluk")
(quasiquote (= nama (unquote name))))
; => (u'=' u'name' u'Cuddles')

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

unquote-splice
unquote-splice memaksa penilaian simbol dalam bentuk kuasipetik, sama seperti
unquote. unquote-splice hanya boleh digunakan apabila simbol tidak disebut petikan mengandungi
nilai boleh lelar, kerana ia "menggabungkan" yang boleh dileterkan ke dalam bentuk petikan kuasi. unquote-splice is
alias kepada ~@ simbol.

(nombor def [1 2 3 4])
(petik kuasi (+ (nombor unquote-splice)))
;=> (u'+' 1L 2L 3L 4L)

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

apabila
apabila adalah sama dengan melainkan jika, kecuali ia menguji apabila bersyarat yang diberikan adalah Benar. Bukan
mungkin untuk mempunyai lagi blok dalam a apabila makro. Berikut menunjukkan pengembangan bagi
makro.

(apabila pernyataan bersyarat)

(jika bersyarat (buat pernyataan))

manakala
manakala digunakan untuk melaksanakan satu atau lebih blok selagi syarat dipenuhi. Yang berikut
contoh akan mengeluarkan "Hello world!" ke skrin selama-lamanya:

(sementara Benar (cetak "Hello dunia!"))

bersama
bersama digunakan untuk membungkus pelaksanaan blok dalam pengurus konteks. Konteksnya
pengurus kemudiannya boleh menyediakan sistem setempat dan meruntuhkannya dengan cara terkawal. The
contoh archetypical penggunaan bersama ialah semasa memproses fail. bersama boleh mengikat konteks kepada an
hujah atau abaikan sepenuhnya, seperti yang ditunjukkan di bawah:

(dengan blok [[arg (expr)]])

(dengan blok [[(expr)]])

(dengan [[arg (expr)] [(expr)]] blok)

Contoh berikut akan membuka BERITA fail dan cetak kandungannya ke skrin. The
fail ditutup secara automatik selepas ia diproses.

(dengan [[f (buka "BERITA")]] (cetak (.baca f)))

dengan-penghias
dengan-penghias digunakan untuk membungkus fungsi dengan yang lain. Fungsi melaksanakan
hiasan harus menerima satu nilai: fungsi yang dihias, dan mengembalikan yang baharu
fungsi. dengan-penghias mengambil sekurang-kurangnya dua parameter: fungsi berfungsi
hiasan dan fungsi yang dihias. Lebih daripada satu fungsi penghias boleh
digunakan; ia akan digunakan mengikut urutan dari paling luar ke paling dalam, iaitu. yang pertama
penghias akan menjadi yang paling luar, dan seterusnya. Penghias dengan hujah dipanggil adil
seperti panggilan fungsi.

(dengan-penghias penghias-keseronokan
(defn beberapa fungsi [] ...)

(dengan penghias penghias1 penghias2 ...
(defn beberapa fungsi [] ...)

(dengan-penghias (decorator arg) ..
(defn beberapa fungsi [] ...)

Dalam contoh berikut, inc-penghias digunakan untuk menghiasi fungsi Selain itu dengan
fungsi yang mengambil dua parameter dan memanggil fungsi yang dihias dengan nilai yang
bertambah 1. Apabila dihias Selain itu dipanggil dengan nilai 1 dan 1, penghujungnya
keputusan akan menjadi 4 (1 + 1 + 1 + 1).

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

=> (dengan-penghias inc-decorator (defn tambahan [ab] (+ ab)))
=> (tambahan 1 1)
4
=> (dengan-decorator inc2-decorator inc-decorator
... (tambahan defn [ab] (+ ab)))
=> (tambahan 1 1)
8

dengan-gensim
Baru dalam versi 0.9.12.

dengan-gensym digunakan untuk menjana satu set gensym untuk digunakan dalam makro. Kod berikut:

(dengan-gensim [abc]
...)

berkembang kepada:

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

SEE JUGA:
Bahagian menggunakan-gensym

menghasilkan
menghasilkan digunakan untuk mencipta objek penjana yang mengembalikan satu atau lebih nilai. Penjana
boleh lelar dan oleh itu boleh digunakan dalam gelung, senarai pemahaman dan lain-lain yang serupa
membina.

Majlis tersebut nombor rawak menunjukkan bagaimana penjana boleh digunakan untuk menjana siri tak terhingga
tanpa memakan jumlah memori yang tidak terhingga.

=> (defn darab [pekali asas]
... (untuk [[(, pekali asas) (pekali tapak zip)]]
... (hasil (* pekali asas))))

=> (darab (julat 5) (julat 5))


=> (nilai komp senarai [nilai (darab (julat 10)) (julat 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (import rawak)
=> (defn rawak-nombor [rendah tinggi]
... (sementara Benar (hasil (.randint rawak rendah tinggi))))
=> (list-comp x [x (ambil 15 (nombor-rawak 1 50))])])
[7, 41, 6, 22, 32, 17, 5, 38, 18, 38, 17, 14, 23, 23, 19]

hasil-daripada
Baru dalam versi 0.9.13.

PYTHON 3.3 DAN UP HANYA!

hasil-daripada digunakan untuk memanggil subgenerator. Ini berguna jika anda mahu coroutine anda
boleh mewakilkan prosesnya kepada coroutine lain, katakan, jika menggunakan sesuatu yang mewah seperti
asyncio.

Hy Teras
Teras Fungsi
butlast
Penggunaan: (tapi lepas coli)

Mengembalikan lelaran semua kecuali item terakhir dalam coll.

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

=> (senarai (terakhir [1]))
[]

=> (senarai (terakhir []))
[]

=> (import itertools)
=> (senarai (ambil 5 (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

coll?
Baru dalam versi 0.10.0.

Penggunaan: (coll? x)

Pulangan Benar if x boleh lelaran dan bukan rentetan.

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

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

=> (coll? "abc")
Palsu

keburukan
Baru dalam versi 0.10.0.

Penggunaan: (keburukan a b)

Mengembalikan sel kontra baharu dengan kereta a dan cdr b.

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

=> (= 'hd (kereta a))
Benar

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

keburukan?
Baru dalam versi 0.10.0.

Penggunaan: (keburukan? foo)

Menyemak sama ada foo ialah sel kontra.

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

=> (keburukan? a)
Benar

=> (kontra? tiada)
Palsu

=> (keburukan? [1 2 3])
Palsu

disember
Penggunaan: (dis x)

Mengembalikan satu kurang daripada x. Bersamaan dengan (- x 1). Menaikkan Taip Kesalahan if (Bukan (nombor? x)).

=> (3 Dis)
2

=> (0 Dis)
-1

=> (12.3 Dis)
11.3

membuka
Baru dalam versi 0.10.0.

Penggunaan: (buka pokok &pilihan [codegen salah])

Buang AST Python untuk Hy yang diberikan pokok kepada keluaran standard. Jika codegen is Benar, fungsinya
sebaliknya mencetak kod Python.

=> (bukak '(cetak "Hello World!"))
modul(
badan=[
Expr(nilai=Panggilan(func=Nama(id='cetak'), args=[Str(s='Hello World!')], kata kunci=[], starargs=Tiada, kwargs=Tiada))])

=> (bukak '(cetak "Hello World!") benar)
print('Hello World!')

kosong?
Penggunaan: (kosong? coli)

Pulangan Benar if coll kosong. Bersamaan dengan (= 0 (len coli)).

=> (kosong? [])
Benar

=> (kosong? "")
Benar

=> (kosong? (, 1 2))
Palsu

setiap?
Baru dalam versi 0.10.0.

Penggunaan: (setiap? pred coli)

Pulangan Benar if (pd x) adalah logik benar untuk setiap x in coll, Jika tidak Palsu. Kembali Benar
if coll kosong.

=> (setiap? genap? [2 4 6])
Benar

=> (setiap? genap? [1 3 5])
Palsu

=> (setiap? genap? [2 4 5])
Palsu

=> (setiap? genap? [])
Benar

terapung?
Penggunaan: (terapung? x)

Pulangan Benar if x ialah pelampung.

=> (terapung? 3.2)
Benar

=> (terapung? -2)
Palsu

malah?
Penggunaan: (malah? x)

Pulangan Benar if x adalah genap. Menaikkan Taip Kesalahan if (Bukan (nombor? x)).

=> (genap? 2)
Benar

=> (genap? 13)
Palsu

=> (genap? 0)
Benar

identiti
Penggunaan: (identiti x)

Mengembalikan hujah yang dibekalkan kepada fungsi.

=> (identiti 4)
4

=> (senarai (identiti peta [1 2 3 4]))
[1 2 3 4]

inc
Penggunaan: (termasuk x)

Mengembalikan satu lebih daripada x. Bersamaan dengan (+ x 1). Menaikkan Taip Kesalahan if (Bukan (nombor? x)).

=> (termasuk 3)
4

=> (termasuk 0)
1

=> (termasuk 12.3)
13.3

contoh?
Penggunaan: (contoh? kelas x)

Pulangan Benar if x adalah contoh dari kelas.

=> (contoh? float 1.0)
Benar

=> (contoh? int 7)
Benar

=> (contoh? str (str "foo"))
Benar

=> (defclass TestClass [objek])
=> (setv inst (TestClass))
=> (contoh? TestClass inst)
Benar

integer?
Penggunaan: (integer? x)

Pulangan Benar if x ialah integer. Untuk Python 2, ini sama ada int or lama. Untuk Python 3,
ini adalah int.

=> (integer? 3)
Benar

=> (integer? -2.4)
Palsu

interleave
Baru dalam versi 0.10.1.

Penggunaan: (selang seli seq1 seq2 ...)

Mengembalikan item pertama yang boleh dilelang dalam setiap urutan, kemudian yang kedua, dsb.

=> (senarai (antara cuti (julat 5) (julat 100 105)))
[0, 100, 1, 101, 2, 102, 3, 103, 4, 104]

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

interpose
Baru dalam versi 0.10.1.

Penggunaan: (interpose item seq)

Mengembalikan unsur boleh lelar bagi jujukan yang dipisahkan oleh item.

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

=> (senarai (interpose -1 (julat 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

boleh diulang?
Penggunaan: (boleh diulang? x)

Pulangan Benar if x boleh lelaran. Objek lelaran mengembalikan lelaran baharu apabila (iter x) is
dipanggil. Berbeza dengan iterator?.

=> ;; berfungsi untuk rentetan
=> (boleh diulang? (str "abcde"))
Benar

=> ;; berfungsi untuk senarai
=> (boleh diulang? [1 2 3 4 5])
Benar

=> ;; berfungsi untuk tupel
=> (boleh diulang? (, 1 2 3))
Benar

=> ;; berfungsi untuk dicts
=> (boleh diulang? {:a 1 :b 2 :c 3})
Benar

=> ;; berfungsi untuk iterator/penjana
=> (boleh diulang? (ulang 3))
Benar

iterator?
Penggunaan: (pembalasan? x)

Pulangan Benar if x adalah lelaran. Iterator adalah objek yang mengembalikan diri mereka sebagai
iterator apabila (iter x) dipanggil. Berbeza dengan boleh diulang?.

=> ;; tidak berfungsi untuk senarai
=> (iterator? [1 2 3 4 5])
Palsu

=> ;; tetapi kita boleh mendapatkan iter daripada senarai
=> (iterator? (iter [1 2 3 4 5]))
Benar

=> ;; tidak berfungsi untuk dict
=> (iterator? {:a 1 :b 2 :c 3})
Palsu

=> ;; buat iterator dari dict
=> (iterator? (iter {:a 1 :b 2 :c 3}))
Benar

senarai*
Penggunaan: (senarai* kepala &rehat ekor)

Menghasilkan rantaian sel kontra bersarang (senarai bertitik) yang mengandungi hujah. Sekiranya
senarai argumen hanya mempunyai satu elemen, kembalikannya.

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

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

=> (senarai* 1)
1

=> (keburukan? (senarai* 1 2 3 4))
Benar

makro kembangkan
Baru dalam versi 0.10.0.

Penggunaan: (makroexpand borang)

Mengembalikan pengembangan makro penuh bagi bentuk.

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

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

makroexpand-1
Baru dalam versi 0.10.0.

Penggunaan: (makroexpand-1 borang)

Mengembalikan pengembangan makro satu langkah bagi bentuk.

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

bergabung-dengan
Baru dalam versi 0.10.1.

Penggunaan: (bergabung-dengan f &rehat peta)

Mengembalikan peta yang terdiri daripada seluruh peta yang dicantumkan dahulu. Jika kunci berlaku dalam
lebih daripada satu peta, pemetaan dari yang terakhir (kiri-ke-kanan) akan digabungkan dengan
pemetaan dalam keputusan dengan memanggil (f val-in-hasil val-in-latter).

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

neg?
Penggunaan: (neg? x)

Pulangan Benar if x adalah kurang daripada sifar. Menaikkan Taip Kesalahan if (Bukan (nombor? x)).

=> (tidak? -2)
Benar

=> (tidak? 3)
Palsu

=> (tidak? 0)
Palsu

tiada?
Penggunaan: (tiada? x)

Pulangan Benar if x is tiada / Tiada.

=> (tiada? tiada)
Benar

=> (tiada? Tiada)
Benar

=> (tiada? 0)
Palsu

=> (setf x nil)
=> (tiada? x)
Benar

=> ;; list.append sentiasa mengembalikan Tiada
=> (tiada? (.tambah [1 2 3] 4))
Benar

tiada?
Penggunaan: (tiada? x)

Pulangan Benar if x is Tiada.

=> (tiada? Tiada)
Benar

=> (tiada? 0)
Palsu

=> (setf x Tiada)
=> (tiada? x)
Benar

=> ;; list.append sentiasa mengembalikan Tiada
=> (tiada? (.tambah [1 2 3] 4))
Benar

ke-
Penggunaan: (nth coll n &pilihan [lalai tiada])

Mengembalikan n-item ke-dalam koleksi, dikira dari 0. Kembalikan nilai lalai, tiada, Jika
di luar sempadan (melainkan dinyatakan sebaliknya). Menaikkan ValueError if n adalah negatif.

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

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

=> (tiada? (nth [1 2 4 7] 5))
Benar

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

=> (nth (ambil 3 (jatuhkan 2 [1 2 3 4 5 6])) 2))
5

=> (nth [1 2 4 7] -1)
Jejak balik (panggilan terakhir terakhir):
...
ValueError: Indeks untuk islice() mestilah Tiada atau integer: 0 <= x <= sys.maxsize.

angka?
Penggunaan: (nombor? x)

Pulangan Benar if x ialah angka, seperti yang ditakrifkan dalam Python nombor.Nombor kelas.

=> (nombor? -2)
Benar

=> (nombor? 3.2)
Benar

=> (nombor? "foo")
Palsu

ganjil?
Penggunaan: (ganjil? x)

Pulangan Benar if x adalah ganjil. Menaikkan Taip Kesalahan if (Bukan (nombor? x)).

=> (ganjil? 13)
Benar

=> (ganjil? 2)
Palsu

=> (ganjil? 0)
Palsu

pos?
Penggunaan: (pos? x)

Pulangan Benar if x adalah lebih besar daripada sifar. Menaikkan Taip Kesalahan if (Bukan (nombor? x)).

=> (pos? 3)
Benar

=> (pos? -2)
Palsu

=> (pos? 0)
Palsu

kedua
Penggunaan: (kedua coli)

Mengembalikan ahli kedua coll. Bersamaan dengan (dapatkan coll 1).

=> (kedua [0 1 2])
1

beberapa
Baru dalam versi 0.10.0.

Penggunaan: (sesetengah pred coli)

Mengembalikan nilai logik-benar yang pertama bagi (pd x) bagi apa apa x in coll, Jika tidak tiada.
Pulangkan tiada if coll kosong.

=> (ada juga? [2 4 6])
Benar

=> (tiada? (ada juga? [1 3 5]))
Benar

=> (tiada? (sesetengah identiti [0 "" []]))
Benar

=> (beberapa identiti [0 "non-empty-string" []])
'bukan rentetan kosong'

=> (tiada? (ada juga? []))
Benar

tali?
Penggunaan: (tali? x)

Pulangan Benar if x ialah rentetan.

=> (rentetan? "foo")
Benar

=> (rentetan? -2)
Palsu

simbol?
Penggunaan: (simbol? x)

Pulangan Benar if x adalah simbol.

=> (simbol? 'foo)
Benar

=> (simbol? '[abc])
Palsu

sifar?
Penggunaan: (sifar? x)

Pulangan Benar if x adalah sifar.

=> (sifar? 3)
Palsu

=> (sifar? -2)
Palsu

=> (sifar? 0)
Benar

Urutan Fungsi
Fungsi jujukan boleh sama ada mencipta atau beroperasi pada jujukan yang berpotensi tidak terhingga tanpa
memerlukan urutan itu direalisasikan sepenuhnya dalam senarai atau bekas yang serupa. Mereka melakukan ini dengan
mengembalikan lelaran Python.

Kita boleh menggunakan penjana nombor Fibonacci tak terhingga kanonik sebagai contoh cara menggunakan
beberapa fungsi ini.

(defn fib []
(setv a 0)
(setv b 1)
(sedangkan benar
(hasil a)
(setv (, ab) (, b (+ ab)))))

Perhatikan (sementara benar ...) gelung. Jika kita menjalankan ini dalam REPL,

=> (fib)


Memanggil fungsi hanya mengembalikan iterator, tetapi tidak berfungsi sehingga kita menggunakannya.
Mencuba sesuatu seperti ini tidak disyorkan kerana gelung tak terhingga akan berjalan sehingga ia
menggunakan semua RAM yang ada, atau dalam kes ini sehingga saya membunuhnya.

=> (senarai (fib))
[1] 91474 membunuh hy

Untuk mendapatkan 10 nombor Fibonacci pertama, gunakan mengambil. Perhatikan bahawa mengambil juga mengembalikan penjana,
jadi saya membuat senarai daripadanya.

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

Untuk mendapatkan nombor Fibonacci pada indeks 9, (bermula dari 0):

=> (nth (fib) 9)
34

kitaran
Penggunaan: (kitaran coli)

Mengembalikan lelaran tak terhingga ahli coll.

=> (senarai (ambil 7 (kitaran [1 2 3])))
[1, 2, 3, 1, 2, 3, 1]

=> (senarai (ambil 2 (kitaran [1 2 3])))
[1, 2]

berbeza
Penggunaan: (berbeza coli)

Mengembalikan iterator yang mengandungi hanya ahli unik dalam coll.

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

=> (senarai (berbeza []))
[]

=> (senarai (berbeza (iter [ 1 2 3 4 3 5 2 ])))
[1, 2, 3, 4, 5]

menggugurkan
Penggunaan: (jatuhkan n coli)

Mengembalikan lelaran, melangkau yang pertama n ahli-ahli coll. Menaikkan ValueError if n is
negatif.

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

=> (senarai (gugurkan 4 [1 2 3 4 5]))
[5]

=> (senarai (gugurkan 0 [1 2 3 4 5]))
[1, 2, 3, 4, 5]

=> (senarai (gugurkan 6 [1 2 3 4 5]))
[]

drop-last
Penggunaan: (drop-last n coli)

Mengembalikan lelaran semua kecuali yang terakhir n item dalam coll. Menaikkan ValueError if n is
negatif.

=> (senarai (jatuhkan-5 terakhir (julat 10 20)))
[10, 11, 12, 13, 14]

=> (senarai (jatuhkan-terakhir 0 (julat 5)))
[0, 1, 2, 3, 4]

=> (senarai (jatuhkan-terakhir 100 (julat 100)))
[]

=> (import itertools)
=> (senarai (ambil 5 (jatuhkan-100 terakhir (itertools.count 10)))))
[10, 11, 12, 13, 14]

drop-while
Penggunaan: (drop-sambil pred coli)

Mengembalikan lelaran, melangkau ahli coll sehingga pred is Palsu.

=> (senarai (jatuhkan semasa genap? [2 4 7 8 9]))
[7, 8, 9]

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

=> (senarai (lepaskan sementara pos? [2 4 7 8 9]))
[]

menapis
Penggunaan: (tapis pred coli)

Mengembalikan iterator untuk semua item dalam coll yang melepasi predikat pred.

Lihat juga mengeluarkan.

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

=> (senarai (tapis genap? [1 2 3 -4 5 -7]))
[2, -4]

meratakan
Baru dalam versi 0.9.12.

Penggunaan: (ratakan coli)

Mengembalikan senarai tunggal semua item dalam coll, dengan meratakan semua senarai yang terkandung dan/atau
tupel.

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

=> (ratakan ["foo" (, 1 2) [1 [2 3] 4] "bar"])
['foo', 1, 2, 1, 2, 3, 4, 'bar']

berulang
Penggunaan: (berulang fn x)

Mengembalikan lelaran daripada x, fn(x), fn(fn(x)), Dll

=> (senarai (ambil 5 (berulang inc 5)))
[5, 6, 7, 8, 9]

=> (senarai (ambil 5 (berulang (fn [x] (* xx)) 5)))
[5, 25, 625, 390625, 152587890625]

membaca
Penggunaan: (baca &pilihan [dari-fail eof])

Membaca ungkapan Hy seterusnya daripada daripada fail (ingkar ke sys.stdin), dan boleh mengambil a
bait tunggal sebagai EOF (lalai kepada rentetan kosong). Menaikkan EOFError if daripada fail berakhir sebelum ini
ungkapan lengkap boleh dihuraikan.

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

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

=> ; dengan mengandaikan "example.hy" mengandungi:
=> ; (cetak "hello")
=> ; (cetak "hyfriends!")
=> (dengan [[f (buka "example.hy")]]
... (cuba
... (sementara benar
... (biar [[exp (baca f)]]
... (buat
... (cetak exp "OHY")
... (eval exp))))
... (tangkap [e EOFError]
... (cetak "EOF!"))))
OHY ('cetak' 'hello')
hello
OHY ('cetak' 'hyfriends!')
kawan kawan!
EOF!

mengeluarkan
Penggunaan: (alih keluar pred coli)

Mengembalikan iterator dari coll dengan unsur yang melepasi predikat, pred, dialih keluar.

Lihat juga menapis.

=> (senarai (alih keluar ganjil? [1 2 3 4 5 6 7]))
[2, 4, 6]

=> (senarai (alih keluar pos? [1 2 3 4 5 6 7]))
[]

=> (senarai (alih keluar neg? [1 2 3 4 5 6 7]))
[1, 2, 3, 4, 5, 6, 7]

mengulangi
Penggunaan: (ulang x)

Mengembalikan lelaran (tak terhingga) daripada x.

=> (senarai (ambil 6 (ulang "s")))
[u's', u's', u's', u's', u's', u's']

berulang kali
Penggunaan: (berulang kali fn)

Mengembalikan iterator dengan memanggil fn berulang kali.

=> (import [rawak [randint]])

=> (senarai (ambil 5 (berulang kali (fn [] (randin 0 10))))))
[6, 2, 0, 6, 7]

mengambil
Penggunaan: (ambil n coli)

Mengembalikan iterator yang mengandungi yang pertama n ahli-ahli coll. Menaikkan ValueError if n is
negatif.

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

=> (senarai (ambil 4 (ulang "s")))
[u', u', u', u']

=> (senarai (ambil 0 (ulang "s")))
[]

ambil-nth
Penggunaan: (ambil-nth n coli)

Mengembalikan iterator yang mengandungi setiap n-ahli ke- coll.

=> (senarai (ambil ke-2 [1 2 3 4 5 6 7]))
[1, 3, 5, 7]

=> (senarai (ambil ke-3 [1 2 3 4 5 6 7]))
[1, 4, 7]

=> (senarai (ambil ke-4 [1 2 3 4 5 6 7]))
[1, 5]

=> (senarai (ambil ke-10 [1 2 3 4 5 6 7]))
[1]

ambil masa
Penggunaan: (ambil-sambil pred coli)

Mengembalikan iterator dari coll selagi pred pulangan Benar.

=> (senarai (ambil sementara pos? [ 1 2 3 -4 5]))
[1, 2, 3]

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

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

zipdengan
Baru dalam versi 0.9.13.

Penggunaan: (zipdengan fn coll ...)

Bersamaan dengan zip, tetapi menggunakan fungsi berbilang hujah dan bukannya mencipta tuple. Jika
zipdengan dipanggil dengan N koleksi, kemudian fn mesti menerima N hujah.

=> (pengendali import)
=> (senarai (zipwith operator.add [1 2 3] [4 5 6]))
[5, 7, 9]

Pembaca Makro
Makro pembaca memberikan Lisp kuasa untuk mengubah suai dan mengubah sintaks dengan cepat. awak tak nak
tatatanda Poland? Makro pembaca boleh melakukannya dengan mudah. Inginkan cara Clojure mempunyai a
regex? Makro pembaca juga boleh melakukan ini dengan mudah.

Syntax
=> (defreader ^ [expr] (print expr))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Hello"
"Helo"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

Hy tidak mempunyai literal untuk tupel. Katakan anda tidak suka (, ...) dan mahu sesuatu yang lain. ini
adalah masalah pembaca makro mampu menyelesaikan dengan cara yang kemas.

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

Anda juga boleh melakukannya seperti Clojure dan mempunyai literal untuk ungkapan biasa!

=> (import semula)
=> (defreader r [expr] `(re.compile ~expr))
=> #r".*"
<_sre.SRE_Corak objek pada 0xcv7713ph15#>

Pelaksanaan
defreader mengambil satu aksara sebagai nama simbol untuk makro pembaca; apa-apa lagi
akan mengembalikan ralat. Dari segi pelaksanaan, defreader mengembang menjadi lambda yang ditutup dengan a
penghias. Penghias ini menyimpan lambda dalam kamus dengan nama modulnya dan
simbol.

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

# berkembang menjadi (dispatch_reader_macro ...) di mana simbol dan ungkapan dihantar ke
fungsi yang betul.

=> #^()
;=> (makro_pembaca_penghantaran ^ ())
=> #^"Hello"
"Helo"

AMARAN :
Oleh kerana pengehadan dalam lexer dan parser Hy, makro pembaca tidak boleh mentakrifkan semula yang ditakrifkan
sintaks seperti ()[]{}. Ini berkemungkinan besar akan ditangani pada masa hadapan.

Dalaman Hy dokumentasi
PERHATIAN:
Bit ini kebanyakannya berguna untuk mereka yang menggodam Hy sendiri, tetapi juga boleh digunakan untuknya
mereka yang mendalami pengaturcaraan makro.

Hy model
Pengenalan kepada Hy model
Model Hy ialah lapisan yang sangat nipis di atas objek Python biasa, yang mewakili sumber Hy
kod sebagai data. Model hanya menambah maklumat kedudukan sumber dan beberapa kaedah untuk
menyokong manipulasi bersih kod sumber Hy, contohnya dalam makro. Untuk mencapai itu
matlamat, model Hy ialah campuran kelas Python asas dan HyObject.

HyObject
hy.models.HyObject ialah kelas asas model Hy. Ia hanya melaksanakan satu kaedah, menggantikan,
yang menggantikan kedudukan sumber objek semasa dengan yang diluluskan sebagai hujah.
Ini membolehkan kami menjejaki kedudukan asal ungkapan yang diubah suai oleh
makro, sama ada dalam pengkompil atau dalam makro hy tulen.

HyObject tidak bertujuan untuk digunakan secara langsung untuk membuat model Hy, tetapi hanya sebagai campuran
untuk kelas lain.

Kompaun model
Senarai dalam kurungan dan kurungan dihuraikan sebagai model kompaun oleh penghurai Hy.

HyList
hy.models.list.HyList ialah kelas asas model Hy "boleh diulang". Kegunaan asasnya adalah untuk
mewakili kurungan [] senarai, yang, apabila digunakan sebagai ungkapan peringkat atas, diterjemahkan kepada
Python menyenaraikan literal dalam fasa penyusunan.

Menambah HyList pada objek boleh lelar lain menggunakan semula kelas objek sebelah kiri,
tingkah laku yang berguna apabila anda ingin menggabungkan objek Hy dalam makro, contohnya.

HyExpression
hy.models.expression.HyExpression mewarisi HyList untuk dalam kurungan () ungkapan. The
hasil penyusunan ungkapan tersebut bergantung pada elemen pertama senarai: the
pengkompil menghantar ungkapan antara bentuk khas pengkompil, makro yang ditentukan pengguna dan
panggilan fungsi Python biasa.

HyDict
hy.models.dict.HyDict mewarisi HyList untuk kurungan kerinting {} ungkapan, yang menyusun
turun ke kamus Python literal.

Keputusan untuk menggunakan senarai dan bukannya dict sebagai kelas asas untuk HyDict membolehkan lebih mudah
manipulasi dicts dalam makro, dengan faedah tambahan membenarkan ungkapan majmuk
sebagai kunci dict (sebagai contoh, the HyExpression Kelas Python tidak boleh dicincang).

atom model
Dalam aliran input, rentetan petikan dua kali, menghormati notasi Python untuk rentetan,
dihuraikan sebagai token tunggal, yang dihuraikan secara langsung sebagai a HyString.

Rentetan aksara tanpa gangguan, tidak termasuk ruang, kurungan, petikan, petikan berganda
dan ulasan, dihuraikan sebagai pengecam.

Pengecam diselesaikan kepada model atom semasa fasa penghuraian dalam susunan berikut:

· HyInteger

· HyFloat

· HyComplex (jika atom tidak terdedah j)

· HyKeyword (jika atom bermula dengan :)

· HySymbol

HyString
hy.models.string.HyString ialah kelas asas model Hy setara rentetan. Ia juga
mewakili literal rentetan petikan dua, "", yang menyusun ke rentetan unicode
literal dalam Python. HyStrings mewarisi objek unicode dalam Python 2, dan objek rentetan dalam
Python 3 (dan oleh itu tidak bergantung kepada pengekodan).

HyString model berasaskan tidak boleh diubah.

Rentetan literal Hy boleh merentangi berbilang baris, dan dianggap oleh penghurai sebagai satu
unit, menghormati Python melarikan diri untuk rentetan unicode.

Angka model
hy.models.integer.HyInteger mewakili literal integer (menggunakan lama taip pada Python 2,
and int pada Python 3).

hy.models.float.HyFloat mewakili literal titik terapung.

hy.models.complex.HyComplex mewakili literal yang kompleks.

Model berangka dihuraikan menggunakan rutin Python yang sepadan dan python berangka yang sah
literal akan ditukar menjadi rakan sejawatannya Hy.

HySymbol
hy.models.symbol.HySymbol ialah model yang digunakan untuk mewakili simbol dalam bahasa Hy. Ia
mewarisi HyString.

HySymbol objek rosak dalam fasa penghuraian, untuk membantu kebolehoperasian Python:

· Simbol yang dikelilingi oleh asterisk (*) ditukar kepada huruf besar;

· Sengkang (-) dijadikan garis bawah (_);

· Satu tanda soal di belakang (?) bertukar menjadi peneraju ialah_.

Kaveat: kerana penggumpalan dilakukan semasa fasa penghuraian, adalah mungkin untuk
menjana HySymbols secara pemrograman yang tidak boleh dijana dengan kod sumber Hy. Seperti a
mekanisme digunakan oleh gensym untuk menjana simbol "tidak dilatih".

HyKeyword
hy.models.keyword.HyKeyword mewakili kata kunci dalam Hy. Kata kunci ialah simbol bermula dengan
a :. Kelas mewarisi HyString.

Untuk membezakan HyKeywords dari HySymbols, tanpa kemungkinan (secara tidak sengaja)
pertembungan, watak unikod penggunaan persendirian "\uFDD0" ditambah dengan kata kunci literal
sebelum penyimpanan.

Kekurangan Sel-sel
hy.models.cons.HyCons ialah perwakilan mesra Python keburukan sel-sel. Sel kontra ialah
amat berguna untuk meniru ciri varian LISP "biasa" seperti Skim atau Biasa
Lisp.

Sel kontra ialah objek 2 item, mengandungi a kereta (kepala) dan a Cdr (ekor). Dalam beberapa Lisp
varian, sel kontra ialah blok binaan asas, dan ungkapan-S sebenarnya
diwakili sebagai senarai terpaut sel kontra. Ini tidak berlaku di Hy, seperti biasa
ungkapan dibuat daripada senarai Python yang dibalut dengan a HyExpression. Walau bagaimanapun HyCons
meniru tingkah laku varian Lisp "biasa" dengan demikian:

· (keburukan sesuatu tiada) is (HyExpression [sesuatu])

· (keburukan sesuatu beberapa senarai) is ((jenis beberapa senarai) (+ [sesuatu] beberapa senarai)) (jika
beberapa-senarai mewarisi dari senarai).

· (dapatkan (keburukan a b) 0) is a

· (hirisan (keburukan a b) 1) is b

Hy menyokong sintaks senarai bertitik, di mana '(a . b) cara (keburukan 'a 'b) and '(a b . c) cara
(keburukan 'a (keburukan 'b 'c)). Jika pengkompil menemui sel kontra di peringkat atas, ia meningkat
ralat penyusunan.

HyCons membungkus hujah yang diluluskan (kereta dan cdr) dalam jenis Hy, untuk memudahkan manipulasi
sel kontra dalam konteks makro.

Hy Dalaman Teori
Gambaran Keseluruhan
Bahagian dalaman Hy berfungsi dengan bertindak sebagai front-end kepada kod bait Python, supaya Hy itu sendiri
menyusun ke Python Bytecode, membenarkan masa jalan Python yang tidak diubah suai untuk menjalankan kod Hy,
tanpa disedari.

Cara kami melakukan ini ialah dengan menterjemahkan Hy ke dalam struktur data AST Python dalaman, dan
membina AST itu ke dalam kod bait Python menggunakan modul daripada piawaian Python
perpustakaan, supaya kita tidak perlu menduplikasi semua kerja dalaman Python untuk setiap
keluaran Python tunggal.

Hy bekerja dalam empat peringkat. Bahagian berikut akan merangkumi setiap langkah Hy dari sumber ke
masa berjalan.

Langkah 1 and 2: Tokenizing and Parsing
Peringkat pertama menyusun Hy ialah memasukkan sumber ke dalam token yang boleh kita tangani. Kami
gunakan projek yang dipanggil rply, yang merupakan penghurai yang sangat bagus (dan pantas), ditulis dalam subset
daripada Python dipanggil rpython.

Kod lexing semuanya ditakrifkan dalam hy.lex.lexer. Kod ini kebanyakannya hanya mentakrifkan Hy
tatabahasa, dan semua bahagian keras sebenar dijaga oleh rply -- kami hanya menentukan
"panggilan balik" untuk rply masuk hy.lex.parser, yang mengambil token yang dijana, dan mengembalikan
model Hy.

Anda boleh menganggap model Hy sebagai "AST" untuk Hy, itulah yang dikendalikan oleh Makro
(secara langsung), dan itulah yang digunakan pengkompil apabila ia menyusun Hy turun.

SEE JUGA:
seksyen Hy model untuk mendapatkan maklumat lanjut tentang model Hy dan maksudnya.

Langkah 3: Hy Penyusunan kepada Python AST
Di sinilah kebanyakan keajaiban dalam Hy berlaku. Di sinilah kami mengambil Hy AST (model),
dan menyusunnya ke dalam Python AST. Beberapa perkara lucu berlaku di sini untuk mengatasi beberapa perkara
masalah dalam AST, dan bekerja dalam pengkompil ialah beberapa kerja paling penting yang kami lakukan
ada.

Penyusunnya agak rumit, jadi jangan berasa sedih jika anda tidak mengecapnya pada pukulan pertama,
ia mungkin mengambil sedikit masa untuk menjadi betul.

Titik masuk utama kepada Pengkompil ialah HyASTCompiler.compile. Kaedah ini digunakan, dan
satu-satunya kaedah "awam" sebenar pada kelas (iaitu, kami tidak benar-benar menjanjikan
API di luar kaedah itu).

Malah, secara dalaman, kita tidak berulang secara langsung, hampir selalu memaksa
pokok Hy melalui menyusun, dan selalunya akan melakukan ini dengan sub-elemen ungkapan
yang kita ada. Terserah kepada penghantar berasaskan Jenis untuk menghantar sub-elemen dengan betul.

Semua kaedah yang membentuk kompilasi ditandakan dengan @builds() penghias. Awak boleh
sama ada lulus kelas model Hy yang dikompilasinya, atau anda boleh menggunakan rentetan untuknya
ungkapan. Saya akan membersihkan ini dalam satu saat.

pertama Masa latihan Jenis-Penghantaran
Mari kita mulakan dalam menyusun kaedah. Perkara pertama yang kita lakukan ialah menyemak Jenis perkara itu
kami sedang membina. Kami melihat ke atas untuk melihat sama ada kami mempunyai kaedah yang boleh membina jenis() bahawa kita
mempunyai, dan menghantar kepada kaedah yang boleh mengendalikannya. Jika kita tidak mempunyai kaedah yang boleh
membina jenis itu, kami meningkatkan dalaman Pengecualian.

Sebagai contoh, jika kita mempunyai a HyString, kami mempunyai hampir 1-ke-1 pemetaan Hy AST kepada Python
AST. The compile_string kaedah mengambil HyString, dan mengembalikan an ast.Str() itu
diisi dengan nombor baris dan kandungan yang betul.

Makro-Kembangkan
Jika kita mendapat a HyExpression, kami akan cuba untuk melihat sama ada ini Makro yang diketahui, dan menolak untuk mempunyai
ia berkembang dengan menyeru hy.macros.macroexpand, kemudian tolak hasilnya semula ke dalam
HyASTCompiler.compile.

kedua Masa latihan Ekspresi-Penghantaran
Satu-satunya kes istimewa ialah HyExpression, kerana kita perlu mencipta AST yang berbeza bergantung
pada borang khas berkenaan. Sebagai contoh, apabila kita memukul an (jika benar benar salah), Kita
perlu menjana a ast.Jika, dan susun sub-nod dengan betul. Di sinilah @builds()
dengan String sebagai hujah masuk.

Bagi compile_expression (yang ditakrifkan dengan @builds(HyExpression)) akan dihantar
berdasarkan rentetan hujah pertama. Jika, atas sebab tertentu, hujah pertama tidak
rentetan, ia akan mengendalikan kes itu juga dengan betul (kemungkinan besar dengan menaikkan satu Pengecualian).

Jika String tidak diketahui oleh Hy, ia akan membuat lalai untuk mencipta ast.Panggil, yang akan cuba
lakukan panggilan masa jalan (dalam Python, sesuatu seperti foo()).

Isu Hit bersama Python AST
Python AST hebat; itulah yang membolehkan kami menulis projek yang begitu hebat di atasnya
Python tanpa perlu melawan Python terlalu keras. Seperti mana-mana, kami telah mendapat bahagian yang saksama
isu, dan berikut ialah senarai pendek yang biasa anda hadapi.

Python membezakan antara Penyata and Ungkapan.

Ini mungkin tidak terdengar seperti masalah besar -- sebenarnya, kepada kebanyakan pengaturcara Python, ini akan berlaku
tidak lama lagi menjadi detik "Baiklah, ya".

Dalam Python, melakukan sesuatu seperti:

cetak Untuk x in pelbagai(10): lulus, Kerana cetak mencetak ungkapan, dan Untuk bukan sebuah
ungkapan, ia adalah pernyataan aliran kawalan. Perkara seperti 1 + 1 adalah Ungkapan, sebagaimana adanya lambda
x: 1 + x, tetapi ciri bahasa lain, seperti if, Untuk, Atau manakala adalah kenyataan.

Oleh kerana mereka tidak mempunyai "nilai" kepada Python, ini menjadikan bekerja dalam Hy sukar, sejak melakukan sesuatu
seperti (cetak (jika benar benar salah)) bukan sahaja biasa, ia dijangka.

Akibatnya, kami mengosongkan sesuatu secara automatik menggunakan a Hasilnya objek, di mana kami menawarkan apa-apa ast.stmt
yang perlu lari, dan satu ast.expr yang boleh digunakan untuk mendapatkan nilai apa sahaja
baru sahaja dijalankan. Hy melakukan ini dengan memaksa tugasan kepada sesuatu semasa berlari.

Sebagai contoh, Hy:

(cetak (jika benar benar salah))

Akan bertukar menjadi:

jika Benar:
_nama_mangled_here = Benar
lain:
_nama_mangled_here = Salah

cetak _nama_mangled_di sini

OK, itu adalah sedikit pembohongan, kerana kami sebenarnya mengubah pernyataan itu menjadi:

cetak Betul jika Betul lagi Salah

Dengan memaksa sesuatu menjadi an ast.expr jika kita boleh, tetapi idea umum berlaku.

Langkah 4: Python Bykod Output and Runtime
Selepas kita mempunyai pokok Python AST yang lengkap, kita boleh mencuba dan menyusunnya kepada Python
bytecode dengan menolaknya menipu. Mulai sekarang, kami tidak lagi terkawal, dan
Python menjaga segala-galanya. Inilah sebabnya perkara seperti jejak balik Python, pdb dan
aplikasi django berfungsi.

Hy Makro
Menggunakan gensym Untuk lebih selamat Makro
Apabila menulis makro, seseorang mesti berhati-hati untuk mengelak daripada menangkap pembolehubah luaran atau menggunakan
nama pembolehubah yang mungkin bercanggah dengan kod pengguna.

Kami akan menggunakan contoh makro nif (Lihat
http://letoverlambda.com/index.cl/guest/chap3.html#sec_5 untuk penerangan yang lebih lengkap.)
nif adalah contoh, sesuatu seperti angka if, di mana berdasarkan ungkapan, salah satu daripada
3 bentuk dipanggil bergantung kepada sama ada ungkapan itu positif, sifar atau negatif.

Pas pertama mungkin seperti:

(defmacro nif [expr pos-form zero-form neg-form]
`(biarkan [[nama kabur ~expr]]
(cond [(pos? obscure-name) ~pos-form]
[(sifar? nama tidak jelas) ~bentuk sifar]
[(neg? kabur-nama) ~neg-bentuk])))

di mana nama yang tidak jelas adalah percubaan untuk memilih beberapa nama pembolehubah supaya tidak bercanggah dengan yang lain
kod. Tetapi sudah tentu, walaupun berniat baik, ini bukan jaminan.

Kaedah gensym direka untuk menjana simbol baharu yang unik untuk majlis sedemikian.
Versi yang lebih baik daripada nif akan menjadi:

(defmacro nif [expr pos-form zero-form neg-form]
(biarkan [[g (gensym)]]
`(biarkan [[~g ~expr]]
(cond [(pos? ~g) ~pos-form]
[(sifar? ~g) ~bentuk sifar]
[(neg? ~g) ~neg-form]))))

Ini adalah kes yang mudah, kerana hanya terdapat satu simbol. Tetapi jika ada keperluan untuk beberapa
gensym's terdapat makro kedua dengan-gensyms yang pada asasnya berkembang kepada satu siri biarkan
pernyataan:

(dengan-gensim [abc]
...)

berkembang kepada:

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

jadi kami ditulis semula nif kelihatan seperti:

(defmacro nif [expr pos-form zero-form neg-form]
(dengan-gensim [g]
`(biarkan [[~g ~expr]]
(cond [(pos? ~g) ~pos-form]
[(sifar? ~g) ~bentuk sifar]
[(neg? ~g) ~neg-form]))))

Akhirnya, walaupun kita boleh membuat makro baharu yang melakukan semua ini untuk kita. defmakro/g! akan mengambil
semua simbol yang bermula dengan g! dan secara automatik memanggil gensym dengan bakinya
simbol. Jadi g!a akan menjadi (gensym "a").

Versi akhir kami nif, dibina dengan defmakro/g! menjadi:

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

Semakan Makro Argumen and Menaikkan Pengecualian
Hy Pengkompil Terbina Dalam

CONTRIBUTOR MODUL INDEKS

Kandungan:

Anaforik Makro
Baru dalam versi 0.9.12.

Modul makro anafora menjadikan pengaturcaraan berfungsi dalam Hy sangat ringkas dan mudah
dibaca.
Makro anaforik ialah sejenis makro pengaturcaraan yang sengaja menangkap beberapa bentuk
dibekalkan kepada makro yang mungkin dirujuk oleh anafora (ungkapan merujuk
kepada yang lain). — Wikipedia (http://en.wikipedia.org/wiki/Anaphoric_macro)

Makro
ap-jika
Penggunaan: (ap-jika (foo) (cetak ia))

Menilai bentuk pertama untuk kebenaran, dan mengikatnya it dalam kedua-dua benar dan palsu
cawangan.

ap-setiap
Penggunaan: (ap-setiap [1 2 3 4 5] (cetak ia))

Nilaikan borang untuk setiap elemen dalam senarai untuk kesan sampingan.

ap-setiap-sementara
Penggunaan: (ap-setiap-sementara senarai pred badan)

Nilaikan bentuk untuk setiap elemen di mana bentuk predikat kembali Benar.

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

peta-ap
Penggunaan: (ap-peta bentuk senarai)

Bentuk anafora peta berfungsi seperti peta biasa kecuali fungsi
objek ia mengambil bentuk Hy. Nama istimewa it terikat pada objek semasa daripada
senarai dalam lelaran.

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

ap-peta-bila
Penggunaan: (ap-peta-bila predfn rep senarai)

Nilaikan pemetaan ke atas senarai menggunakan fungsi predikat untuk menentukan masa untuk menggunakan
bentuk.

=> (senarai (ap-map-bila ganjil? (* ia 2) [1 2 3 4]))
[2, 2, 6, 4]

=> (senarai (ap-map-bila genap? (* ia 2) [1 2 3 4]))
[1, 4, 3, 8]

penapis ap
Penggunaan: (penapis ap bentuk senarai)

Seperti peta-ap kami mengambil bentuk khas dan bukannya fungsi untuk menapis unsur-unsur
senarai. Nama istimewa it terikat kepada elemen semasa dalam lelaran.

=> (senarai (penapis-ap (> (* ia 2) 6) [1 2 3 4 5]))
[4, 5]

ap-menolak
Penggunaan: (ap-tolak bentuk senarai)

Fungsi ini melakukan yang bertentangan dengan penapis ap, ia menolak unsur-unsur yang melepasi
predikat . Nama istimewa it terikat kepada elemen semasa dalam lelaran.

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

ap-dotimes
Penggunaan (ap-dotimes n badan)

Fungsi ini menilai badan n kali, dengan pembolehubah khas it terikat dari 0 kepada
1-n. Ia berguna untuk kesan sampingan.

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

ap-first
Penggunaan (ap-first predfn senarai)

Fungsi ini mengembalikan elemen pertama yang melepasi predikat atau Tiada, dengan
pembolehubah khas it terikat kepada elemen semasa dalam lelaran.

=>(ap-first (> it 5) (julat 10))
6

ap-terakhir
Penggunaan (ap-last predfn senarai)

Fungsi ini mengembalikan elemen terakhir yang melepasi predikat atau Tiada, dengan yang istimewa
berubah-ubah it terikat kepada elemen semasa dalam lelaran.

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

ap-mengurangkan
Penggunaan (ap-mengurangkan bentuk senarai &pilihan nilai awal)

Fungsi ini mengembalikan hasil penggunaan borang kepada 2 elemen pertama dalam badan dan
menggunakan keputusan dan elemen ke-3 dan lain-lain sehingga senarai itu habis. Secara pilihan an
nilai awal boleh dibekalkan jadi fungsi akan digunakan pada nilai awal dan
elemen pertama sebaliknya. Ini mendedahkan elemen yang diulang sebagai it dan semasa
nilai terkumpul sebagai acc.

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

gelung/berulang
Baru dalam versi 0.10.0.

. gelung / berulang makro memberi pengaturcara cara mudah untuk menggunakan pengoptimuman panggilan ekor (TCO)
dalam kod Hy mereka.
Panggilan ekor ialah panggilan subrutin yang berlaku dalam prosedur lain sebagai panggilan terakhir
tindakan; ia mungkin menghasilkan nilai pulangan yang kemudiannya dikembalikan dengan serta-merta oleh panggilan tersebut
prosedur. Jika mana-mana panggilan yang dilakukan oleh subrutin, yang akhirnya mungkin membawanya
kepada subrutin yang sama ini dipanggil semula ke rantai panggilan, berada dalam kedudukan ekor,
subrutin sedemikian dikatakan sebagai rekursif ekor, yang merupakan kes pengulangan khas.
Panggilan ekor adalah penting kerana ia boleh dilaksanakan tanpa menambah tindanan baharu
bingkai ke timbunan panggilan. Kebanyakan bingkai prosedur semasa tidak diperlukan apa-apa
lebih banyak lagi, dan ia boleh digantikan dengan bingkai panggilan ekor. Program itu kemudiannya boleh melompat
kepada subrutin yang dipanggil. Menghasilkan kod sedemikian dan bukannya urutan panggilan standard adalah
dipanggil penghapusan panggilan ekor, atau pengoptimuman panggilan ekor. Penghapusan panggilan ekor membenarkan
panggilan prosedur dalam kedudukan ekor untuk dilaksanakan dengan cekap seperti pernyataan goto,
sekali gus membolehkan pengaturcaraan berstruktur yang cekap. — Wikipedia (-
http://en.wikipedia.org/wiki/Tail_call)

Makro
gelung
gelung mewujudkan titik rekursi. Dengan gelung, berulang mengikat semula pembolehubah yang ditetapkan dalam
titik rekursi dan menghantar pelaksanaan kod kembali ke titik rekursi itu. Jika berulang digunakan dalam
kedudukan bukan ekor, pengecualian dilemparkan.

Penggunaan: (gelung pengikatan &rehat badan)

Contoh:

(memerlukan hy.contrib.loop)

(defn faktorial [n]
(gelung [[dalam] [acc 1]]
(jika (sifar? i)
acc
(berulang (dis i) (* acc i)))))

(faktorial 1000)

defmulti
Baru dalam versi 0.10.0.

defmulti membolehkan anda arity-overload fungsi dengan bilangan args dan/atau kwarg yang diberikan.
Diinspirasikan oleh pandangan Clojure defn.

=> (memerlukan hy.contrib.multi)
=> (defmulti fun
... ([a] "a")
... ([ab] "ab")
... ([abc] "abc"))
=> (seronok 1)
"a"
=> (seronok 1 2)
"ab"
=> (seronok 1 2 3)
"abc"

MENGGODAM ON HY

Sertai kami Hyve!
Sila datang menggodam Hy!

Sila datang lepak dengan kami #hy on irc.freenode.net!

Sila bercakap mengenainya di Twitter dengan #hy Hashtag!

Sila blog tentangnya!

Tolong jangan sembur cat pada pagar jiran anda (tanpa bertanya elok-elok)!

hack!
Melakukan ini:

1. Buat a maya persekitaran:

$ virtualenv venv

dan aktifkannya:

$ . venv/bin/activate

atau gunakan virtualenvwrapper untuk mencipta dan mengurus persekitaran maya anda:

$ mkvirtualenv hy
$ kerjakan hy

2. Dapatkan kod sumber:

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

atau gunakan garpu anda:

$ git klon [e-mel dilindungi]: /hy.git

3. Pasang untuk penggodaman:

$ cd hy/
$ pip install -e .

4. Pasang keperluan pembangunan-y lain:

$ pip install -r requirements-dev.txt

5. Lakukan perkara yang mengagumkan; membuat seseorang menjerit gembira/jijik dengan apa yang telah anda lakukan.

Ujian!
Ujian terletak di ujian/. Kami guna hidung.

Untuk menjalankan ujian:

$ ujian hidung

Tulis ujian---ujian adalah bagus!

Selain itu, adalah baik untuk menjalankan ujian untuk semua platform yang disokong dan untuk mematuhi PEP 8
kod. Anda boleh melakukannya dengan menjalankan tox:

$ tox

Dokumen!
Dokumentasi terletak di dokumen /. Kami guna Sphinx.

Untuk membina dokumen dalam HTML:

$ cd dokumen
$ buat html

Tulis dokumen---dokumen bagus! Walaupun doc ini!

menyumbang
Sumbangan dialu-alukan & amat dihargai, setiap sedikit membantu dalam menjadikan Hy lebih banyak
hebat.

Permintaan tarik adalah hebat! Kami menyayangi mereka; berikut adalah panduan ringkas:

· Fork repo dan buat cabang topik untuk ciri/pembetulan. Elakkan membuat perubahan secara langsung
pada cawangan induk.

· Semua ciri masuk hendaklah disertakan dengan ujian.

· Sebelum anda menyerahkan PR, sila jalankan ujian dan semak kod anda terhadap gaya
panduan. Anda boleh melakukan kedua-dua perkara ini sekaligus:

$ membuat d

· Jadikan komit ke dalam unit logik, supaya lebih mudah untuk dijejak & dinavigasi kemudian. Sebelum ini
menghantar PR, cuba hapuskan komitmen ke dalam set perubahan yang mudah untuk dikembalikan
nanti. Juga, pastikan anda tidak meninggalkan ruang kosong palsu dalam set perubahan; ini
mengelakkan penciptaan komit pembetulan ruang putih kemudian.

· Setakat menghantar mesej, cuba patuhi perkara berikut:

· Cuba berpegang pada had 50 aksara untuk baris pertama mesej komit Git.

· Untuk lebih terperinci/penjelasan, ikuti ini dengan baris kosong dan teruskan
menerangkan komitmen secara terperinci.

· Akhir sekali, tambahkan diri anda pada fail AUTHORS (sebagai komitmen berasingan): anda layak mendapatnya :)

· Semua perubahan yang masuk perlu diterima oleh 2 ahli pasukan teras Hylang yang berbeza.
Semakan tambahan jelas dialu-alukan, tetapi kami memerlukan sekurang-kurangnya 2 tandatangan untuk mana-mana
berubah.

· Jika ahli teras menghantar PR, sila cari 2 ahli teras yang tidak termasuk
penghantar PR. Idea di sini ialah seseorang boleh bekerja dengan pengarang PR, dan acks kedua
keseluruhan set perubahan.

· Untuk dokumentasi & perubahan remeh lain, kami baik untuk bergabung selepas satu ACK. Kami mempunyai
liputan rendah, jadi adalah bagus untuk memastikan halangan itu rendah.

Teras Pasukan
Pasukan pembangunan teras Hy terdiri daripada pembangun berikut:

· Julian Danjou

· Morten Linderud

· J Kenneth Raja

· Gergely Nagy

· Tuukka Turto

· Karen Rustad

· Abhishek L

· Christopher Allan Webber

· Konrad Hinsen

· Akan Kahn-Hijau

· Paul Tagliamonte

· Nicolas Dandrimont

· Bob Tolbert

· mengamuk Peksag

· Clinton N. Dreisbach

· dia semaj

Gunakan hy dalam talian menggunakan perkhidmatan onworks.net