hy - Online di Awan

PROGRAM:

NAMA

hy - hy Dokumentasi [image: Hy] [image]

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

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

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

Daftar hylang-diskusi

IRC #hai di Freenode

Membangun status
Travis CI.TIDAK INDENT

Hy adalah dialek Lisp yang luar biasa yang tertanam dalam Python.

Karena Hy mengubah kode Lisp-nya menjadi Pohon Sintaks Abstrak Python, Anda memiliki
seluruh dunia Python yang indah di ujung jari Anda, dalam bentuk Lisp!

Isi:

MULAI CEPAT

[gambar: Pelukan Karen Rustard] [gambar]

(Terima kasih kepada Karen Rustad untuk Cuddles!)

BAGAIMANA UNTUK DAPATKAN HY NYATA FAST:

1. Membuat maya Ular sanca Lingkungan Hidup.

2. Aktifkan Lingkungan Python Virtual Anda.

3. Memasang hy dari PyPI dengan biji install hy.

4. Mulai REPL dengan hy.

5. Ketik barang di REPL:

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

dll

6. Tekan CTRL-D setelah selesai.

OMG! Itu menakjubkan! I ingin untuk menulis a Hy program.

7. Buka editor pemrograman elit dan ketik:

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

8. Simpan sebagai mengagumkan.

9. Dan jalankan program Hy pertama Anda:

hai luar biasa

10.
Ambil napas dalam-dalam agar tidak hiperventilasi.

11.
Tersenyumlah dengan jahat dan menyelinap ke hydeaway Anda dan melakukan hal-hal yang tak terkatakan.

TUTORIAL

Selamat datang di tutorial Hy!

Singkatnya, Hy adalah dialek Lisp, tetapi dialek yang mengubah strukturnya menjadi Python ...
secara harfiah konversi ke pohon sintaksis abstrak Python! (Atau untuk membuatnya lebih kasar
istilah, Hy adalah cadel-stick pada Python!)

Ini cukup keren karena artinya Hy adalah beberapa hal:

· Cadel yang terasa sangat Pythonic

· Untuk Lisper, cara yang bagus untuk menggunakan kekuatan gila Lisp tetapi di dunia luas Python
perpustakaan (mengapa ya, Anda sekarang dapat menulis aplikasi Django di Lisp!)

· Untuk Pythonista, cara yang bagus untuk mulai menjelajahi Lisp, dari kenyamanan Python!

· Untuk semua orang: bahasa yang menyenangkan yang memiliki banyak ide rapi!

Dasar intro untuk Pelat untuk Pythonista
Oke, mungkin Anda belum pernah menggunakan Lisp sebelumnya, tetapi Anda pernah menggunakan Python!

Program "hello world" di Hy sebenarnya sangat sederhana. Mari kita coba:

(cetak "halo dunia")

Lihat? Mudah! Seperti yang mungkin sudah Anda duga, ini sama dengan versi Python dari:

cetak "halo dunia"

Untuk menambahkan beberapa matematika super sederhana, kita bisa melakukan:

(+ 1 3)

Yang akan mengembalikan 4 dan akan setara dengan:

1 + 3

Apa yang akan Anda perhatikan adalah bahwa item pertama dalam daftar adalah fungsi yang dipanggil dan
argumen lainnya adalah argumen yang diteruskan. Faktanya, di Hy (seperti kebanyakan
Lisps) kita dapat meneruskan beberapa argumen ke operator plus:

(+ 1 3 55)

Yang akan mengembalikan 59.

Mungkin Anda pernah mendengar tentang Lisp sebelumnya tetapi tidak tahu banyak tentangnya. Lisp tidak sesulit kamu
mungkin berpikir, dan Hy mewarisi dari Python, jadi Hy adalah cara yang bagus untuk mulai belajar Lisp.
Hal utama yang jelas tentang Lisp adalah bahwa ada banyak tanda kurung. Ini mungkin
tampak membingungkan pada awalnya, tetapi tidak begitu sulit. Mari kita lihat beberapa matematika sederhana itu
dibungkus dengan tanda kurung yang bisa kita masukkan ke dalam interpreter Hy:

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

Ini akan mengembalikan 38. Tapi mengapa? Yah, kita bisa melihat ekspresi yang setara di
ular piton:

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

Jika Anda mencoba mencari tahu bagaimana cara kerja di atas dengan python, Anda tentu saja akan
tentukan hasilnya dengan menyelesaikan setiap kurung dalam. Itu ide dasar yang sama di
Hai. Mari kita coba latihan ini terlebih dahulu dengan Python:

hasil = ((1 + 3 + 88) / 2) - 8
# disederhanakan menjadi...
hasil = (92 / 2) - 8
# disederhanakan menjadi...
hasil = 46 - 8
# disederhanakan menjadi...
hasil = 38

Sekarang mari kita coba hal yang sama di Hy:

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

Seperti yang mungkin Anda duga, ekspresi terakhir ini dengan setv berarti untuk menetapkan variabel
"hasil" ke 38.

Lihat? Tidak terlalu keras!

Ini adalah premis dasar dari Lisp. Lisp adalah singkatan dari "pemrosesan daftar"; ini berarti bahwa
struktur program sebenarnya adalah daftar daftar. (Jika Anda terbiasa dengan Python
daftar, bayangkan seluruh struktur yang sama seperti di atas tetapi dengan tanda kurung siku sebagai gantinya, apa saja
Anda akan dapat melihat struktur di atas sebagai program dan struktur data.) Ini adalah
lebih mudah dipahami dengan lebih banyak contoh, jadi mari kita tulis program Python sederhana, uji,
dan kemudian tampilkan program Hy yang setara:

def simple_percakapan():
print "Halo! Saya ingin mengenal Anda. Ceritakan tentang diri Anda!"
nama = raw_input("Siapa nama anda? ")
umur = raw_input("Berapa umurmu?")
print "Halo " + nama + "! Saya melihat Anda berusia " + usia + " tahun."

percakapan_sederhana()

Jika kami menjalankan program ini, itu mungkin seperti:

Halo! Saya ingin mengenal Anda. Ceritakan tentang dirimu!
Siapa nama kamu? Gary
Berapa umurmu? 38
Halo Garry! Saya melihat Anda berusia 38 tahun.

Sekarang mari kita lihat program Hy yang setara:

(defn percakapan sederhana []
(cetak "Halo! Saya ingin mengenal Anda. Ceritakan tentang diri Anda!")
(nama setv (masukan mentah "Siapa nama Anda?"))
(usia setv (masukan mentah "Berapa usia Anda? "))
(cetak (+ "Halo " nama "! Saya melihat Anda adalah "
usia " tahun.")))

(percakapan sederhana)

Jika Anda melihat program di atas, asalkan Anda ingat bahwa elemen pertama di setiap
daftar program adalah fungsi (atau makro... kita akan membahasnya nanti) yang dipanggil
dan sisanya adalah argumen, cukup mudah untuk mengetahui apa artinya semua ini.
(Seperti yang mungkin Anda juga duga, defn adalah metode Hy untuk mendefinisikan metode.)

Namun, banyak orang pada awalnya bingung karena ada begitu banyak tanda kurung,
tetapi ada banyak hal yang dapat membantu membuatnya lebih mudah: jaga agar lekukan tetap bagus dan
gunakan editor dengan pencocokan tanda kurung (ini akan membantu Anda mengetahui apa masing-masing
tanda kurung berpasangan dengan) dan segalanya akan mulai terasa nyaman.

Ada beberapa keuntungan memiliki struktur kode yang sebenarnya merupakan data yang sangat sederhana
struktur sebagai inti dari LISP didasarkan. Untuk satu hal, itu berarti bahwa program Anda adalah
mudah diurai dan seluruh struktur program yang sebenarnya terekspos dengan sangat jelas
kepadamu. (Ada langkah ekstra di hy di mana struktur yang Anda lihat dikonversi ke Python
representasi sendiri ... dalam Lisp "lebih murni" seperti Common Lisp atau Emacs Lisp, data
struktur yang Anda lihat dalam kode dan struktur data yang dieksekusi jauh lebih banyak
benar-benar dekat.)

Implikasi lain dari ini adalah makro: jika struktur program adalah data sederhana
struktur, itu berarti Anda dapat menulis kode yang dapat menulis kode dengan sangat mudah, artinya
mengimplementasikan fitur bahasa yang sama sekali baru bisa sangat cepat. Sebelum Hy, ini bukan
sangat mungkin untuk pemrogram Python ... sekarang Anda juga dapat menggunakan makro yang luar biasa
kekuatan (hanya berhati-hati untuk tidak mengarahkan mereka ke bawah)!

Hy is a rasa lisp Ular sanca
Hy mengonversi ke pohon sintaksis abstrak Python sendiri, jadi Anda akan segera mulai menemukan itu semua
kekuatan python yang sudah dikenal ada di ujung jari Anda.

Anda memiliki akses penuh ke tipe data Python dan pustaka standar di Hy. Mari bereksperimen
dengan ini di hy interpreter:

=> [1 2 3]
[1, 2, 3]
=> {"anjing" "menggonggong"
... "kucing" "meong"}
...
{'anjing': 'menggonggong', 'kucing': 'meong'}
=> (, 1 2 3)
(1, 2, 3)

Jika Anda akrab dengan Lisps lainnya, Anda mungkin tertarik bahwa Hy mendukung Common
Metode kutipan cadel:

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

Anda juga memiliki akses ke semua metode Nice tipe bawaan:

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

Apa ini? Ya memang, ini persis sama dengan:

" fooooo ".strip()

Itu benar --- Lisp dengan notasi titik! Jika kita memiliki string ini ditetapkan sebagai variabel, kita
juga dapat melakukan hal berikut:

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

Bagaimana dengan persyaratan?:

(jika (coba-sesuatu-)
(cetak "ini jika benar")
(cetak "ini jika salah"))

Seperti yang Anda tahu di atas, argumen pertama untuk if adalah tes kebenaran, argumen kedua adalah
badan jika benar, dan argumen ketiga (opsional!) adalah jika salah (mis. lain).

Jika Anda perlu melakukan persyaratan yang lebih kompleks, Anda akan menemukan bahwa Anda tidak memilikinya elif
tersedia di Hy. Sebaliknya, Anda harus menggunakan sesuatu yang disebut cond. Dengan Python, Anda mungkin melakukannya
sesuatu seperti:

Somevar = 33
jika somevar > 50:
print "Variabel itu terlalu besar!"
elif somevar < 10:
print "Variabel itu terlalu kecil!"
lain:
print "Variabel itu benar benar!"

Di Hy, Anda akan melakukan:

(kond
[(> beberapavar 50)
(cetak "Variabel itu terlalu besar!")]
[(< beberapavar 10)
(cetak "Variabel itu terlalu kecil!")]
[benar
(cetak "Variabel itu benar benar!")])

Apa yang akan Anda perhatikan adalah itu cond mematikan antara beberapa pernyataan yang dieksekusi dan
diperiksa secara kondisional untuk benar atau salah, dan kemudian sedikit kode untuk dieksekusi jika ternyata
keluar untuk menjadi kenyataan. Anda juga akan melihat bahwa lain diimplementasikan pada akhirnya hanya dengan
memeriksa benar -- itu karena benar akan selalu benar, jadi jika kita sampai sejauh ini, kita akan
selalu jalankan yang itu!

Anda mungkin memperhatikan di atas bahwa jika Anda memiliki kode seperti:

(jika beberapa kondisi
(tubuh-jika-benar)
(tubuh-jika-salah))

Tapi tunggu! Bagaimana jika Anda ingin mengeksekusi lebih dari satu pernyataan di badan salah satu dari
ini?

Anda dapat melakukan hal berikut:

(jika (coba-sesuatu-)
(melakukan
(cetak "ini jika benar")
(cetak "dan mengapa tidak, mari kita terus berbicara tentang betapa benarnya itu!))
(cetak "yang ini masih salah"))

Anda dapat melihat bahwa kami menggunakan do untuk membungkus beberapa pernyataan. Jika Anda akrab dengan yang lain
Lisps, ini setara dengan prog tempat lain.

Komentar dimulai dengan titik koma:

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

Looping tidak sulit tetapi memiliki semacam struktur khusus. Dengan Python, kita mungkin melakukan:

untuk saya di jarak(10):
print "'i' sekarang di " + str(i)

Setara dalam Hy akan menjadi:

(untuk [i (kisaran 10)]
(cetak (+ "'i' sekarang di " (str i)))))

Anda juga dapat mengimpor dan menggunakan berbagai pustaka Python. Sebagai contoh:

(import)

(jika (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/anotherdir")
(cetak "Hei, jalan itu tidak ada!"))

Manajer konteks Python (dengan pernyataan) digunakan seperti ini:

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

yang setara dengan:

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

Dan ya, kami memiliki pemahaman Daftar! Dengan Python Anda mungkin melakukan:

peluang_kuadrat = [
pow(angka, 2)
untuk nomor dalam jarak(100)
jika angka % 2 == 1]

Di Hy, Anda bisa melakukan ini seperti:

(setv odds-kuadrat
(daftar-komp
(pow nomor 2)
(angka (rentang 100))
(= (% angka 2) 1)))

; Dan, contoh yang dicuri tanpa malu-malu dari halaman Clojure:
; Mari daftar semua blok Papan Catur:

(daftar-komp
(, xy)
(x (kisaran 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 memiliki dukungan untuk berbagai argumen mewah dan argumen kata kunci. Dengan Python kita mungkin
Lihat:

>>> def optional_arg(pos1, pos2, keyword1=None, keyword2=42):
... kembalikan [pos1, pos2, kata kunci1, kata kunci2]
...
>>> optional_arg(1, 2)
[1, 2, Tidak Ada, 42]
>>> optional_arg(1, 2, 3, 4)
[1, 2, 3, 4]
>>> optional_arg(keyword1=1, pos2=2, pos1=3, kata kunci2=4)
[3, 2, 1, 4]

Hal yang sama di Hy:

=> (defn opsional-arg [pos1 pos2 & opsional kata kunci1 [kata kunci2 42]]
... [pos1 pos2 kata kunci1 kata kunci2])
=> (opsional-arg 1 2)
[1 2 Tidak ada 42]
=> (opsional-arg 1 2 3 4)
[1 2 3 4]

Jika Anda menjalankan versi Hy melewati 0.10.1 (misalnya, git master), ada juga yang baru
sintaks argumen kata kunci:

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

Jika tidak, Anda selalu dapat menggunakan menerapkan. Tapi apa? menerapkan?

Apakah Anda terbiasa dengan lewat? * argumen dan ** kwargs dengan Python?:

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

Kita dapat mereproduksi ini dengan menerapkan:

=> (setv args [1 2])
=> (setv kwargs {"keyword2" 3
... "kata kunci1" 4})
=> (terapkan opsional-arg args kwargs)
[1, 2, 4, 3]

Ada juga konstruksi argumen kata kunci bergaya kamus yang terlihat seperti:

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

Perbedaannya di sini adalah karena ini adalah kamus, Anda tidak dapat mengandalkan yang spesifik
memesan argumen.

Hy juga mendukung * argumen dan ** kwargs. Dengan Python:

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

Setara dengan Hy:

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

Akhirnya, tentu saja kita membutuhkan kelas! Dalam Python, kita mungkin memiliki kelas seperti:

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

def get_x(diri):
"" "
Kembalikan salinan x
"" "
kembalikan diri.x

Dalam Hy:

(defclass FooBar [objek]
"Kelas Contoh Lain Lagi"
[[--init--
(fn [diri x]
(setv self.xx)
; Saat ini diperlukan untuk --init-- karena __init__ membutuhkan Tidak ada
; Semoga ini hilang :)
Tidak ada)]

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

Anda juga dapat melakukan atribut tingkat kelas. Dengan Python:

kelas Pelanggan(models.Model):
name = models.CharField (max_length = 255)
alamat = model.TextField()
catatan = model.TextField()

Dalam Hy:

(Pelanggan defclass [models.Model]
[[nama (models.CharField :max-length 255})]
[alamat (models.TextField)]
[catatan (models.TextField)]])

Hy <-> Ular sanca interop
Dengan mengimpor Hy, Anda dapat menggunakan Hy langsung dari Python!

Jika Anda menyimpan yang berikut ini di salam.hy:

(defn menyapa [nama] (cetak "halo dari hy," nama))

Kemudian Anda dapat menggunakannya langsung dari python, dengan mengimpor hy sebelum mengimpor modul. Di dalam
ular piton:

impor hy
salam impor

salam.greet("Foo")

Anda juga dapat mendeklarasikan fungsi dalam python (atau bahkan kelas!) dan menggunakannya di Hy!

Jika Anda menyimpan yang berikut ini di salam.py dengan Python:

salam kenal (nama):
print("Halo, %s" % (nama))

Anda dapat menggunakannya di Hy:

(salam impor)
(.sapa salam "foo")

Untuk menggunakan argumen kata kunci, Anda dapat menggunakan di salam.py:

def menyapa(nama, judul = "Tuan"):
print("Salam, %s %s" % (judul,nama))

(salam impor)
(.sapa salam "Foo")
(.sapa salam "Foo" "Darth")
(terapkan (. salam sapa) ["Foo"] {"title" "Lord"})

Yang akan menghasilkan:

Salam, Pak Foo

Salam, Darth Foo

Salam, Tuan Foo

Protip!
Hy juga menampilkan sesuatu yang dikenal sebagai "makro threading", fitur yang sangat rapi dari
milik Clojure. "Makro threading" (ditulis sebagai ->) digunakan untuk menghindari sarang yang dalam dari
ekspresi.

Makro threading menyisipkan setiap ekspresi ke dalam argumen pertama ekspresi berikutnya
tempat.

Mari kita ambil yang klasik:

(loop (cetak (eval (baca)))))

Daripada menulis seperti itu, kita bisa menulisnya sebagai berikut:

(-> (baca) (eval) (cetak) (loop))

Sekarang, menggunakan python-sh, kami dapat menunjukkan bagaimana makro threading (karena pengaturan python-sh)
dapat digunakan seperti pipa:

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

Yang, tentu saja, berkembang menjadi:

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

Jauh lebih mudah dibaca, bukan? Gunakan makro threading!

HY STYLE GUIDE

“Anda tahu, Menteri, saya tidak setuju dengan Dumbledore dalam banyak hal…tetapi Anda tidak dapat menyangkal bahwa dia
punya gaya…” — Phineas Nigellus Black, menyerobot Pembuat pot dan itu Memesan of itu Phoenix

Panduan gaya Hy dimaksudkan untuk menjadi seperangkat aturan dasar untuk Hyve (ya, komunitas Hy
bangga dengan menambahkan Hy ke semuanya) untuk menulis kode Hy idiomatik. Hy banyak didapat
dari Clojure & Common Lisp, dengan tetap menjaga interopabilitas Python.

Mendahului
Grafik Tao of Hy
Ummon bertanya kepada biksu kepala, "Sutra apa yang kamu ajarkan?"
"Sutra Nirwana."
"Sutra Nirvana memiliki Empat Kebajikan, bukan?"
"Memiliki."
Ummon bertanya, mengambil cangkir, "Berapa banyak kebajikan yang dimiliki ini?"
"Tidak ada sama sekali," kata biarawan itu.
"Tapi orang-orang zaman dulu bilang begitu, kan?" kata Ummon.
"Bagaimana menurutmu tentang apa yang mereka katakan?"
Ummon memukul cangkir dan bertanya, "Kamu mengerti?"
"Tidak," kata biarawan itu.
"Kalau begitu," kata Ummon, "Sebaiknya kau melanjutkan kuliahmu tentang sutra."
— makro (koan)

Berikut ini menggambarkan daftar singkat keputusan desain yang masuk ke dalam pembuatan:
Hai.

· Terlihat seperti Cadel; DTRT dengannya (misalnya tanda hubung berubah menjadi garis bawah, penutup telinga berubah menjadi
huruf besar semua).

· Kami masih Python. Sebagian besar internal menerjemahkan 1:1 ke internal Python.

· Gunakan Unicode di mana-mana.

· Perbaiki keputusan buruk di Python 2 saat kita bisa (lihat divisi_benar).

· Jika ragu, gunakan Python.

· Jika Anda masih tidak yakin, lihat Clojure.

· Jika Anda lebih tidak yakin lagi, lihat Common Lisp.

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

tata ruang & lekukan
· Hindari spasi tambahan. Mereka menyebalkan!

· Indentasi harus 2 spasi (tidak ada hard tab), kecuali jika cocok dengan indentasi
baris sebelumnya.

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

;; Masih oke
(dif fib [n]
(jika (<= n 2) n (+ (fib (- n 1)) (fib (- n 2))))))

;; Masih oke
(dif fib [n]
(jika (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2))))))

;; Histeris konyol
(dif fib [n]
(jika (<= n 2)
n ;; ya, saya suka menekan tombol spasi secara acak
(+ (fib (- n 1)) (fib (- n 2))))))

· Tanda kurung harus tak pernah dibiarkan sendiri, sedih dan kesepian di jalur mereka sendiri.

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

;; Histeris konyol
(dif fib [n]
(jika (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2))))
)
); GAH, BAKAR DENGAN API

· Sejajarkan secara vertikal membiarkan blok.

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

· Komentar sebaris harus dua spasi dari akhir kode; mereka harus selalu memiliki
spasi antara karakter komentar dan awal komentar. Juga, cobalah untuk tidak
komentar yang jelas.

;; Bagus
(setv ind (des x)); pengindeksan dimulai dari 0

;; Sesuai dengan gaya tetapi hanya menyatakan yang sudah jelas
(setv ind (des x)); set indeks ke x-1

;; Buruk
(setv ind (dec x)); mengetik kata-kata untuk bersenang-senang

Pengkodean Gaya
· Sebagai konvensi, cobalah untuk tidak menggunakan def untuk apa pun selain variabel global; menggunakan setv
di dalam fungsi, loop, dll.

;; Baik (dan disukai)
(def *batas* 400000)

(defn fib [ab]
(sementara benar
(hasil a)
(setv (, ab) (, b (+ ab))))))

;; Buruk (dan tidak disukai)
(defn fib [ab]
(sementara benar
(hasil a)
(def (, ab) (, b (+ ab))))))

· Jangan gunakan sintaks s-expression di mana sintaks vektor dimaksudkan. Misalnya, fakta
bahwa yang pertama dari dua contoh ini berfungsi hanya karena kompilernya tidak terlalu
ketat. Pada kenyataannya, sintaks yang benar di tempat-tempat seperti ini adalah yang terakhir.

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

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

· Gunakan makro utas atau makro ekor utas saat menghadapi sangat bersarang
s-ekspresi. Namun, berhati-hatilah saat menggunakannya. Gunakan saat kejelasan dan
keterbacaan meningkat; jangan membangun ekspresi yang berbelit-belit, sulit dipahami.

;; Lebih disukai
(def *nama*
(dengan [f (buka "names.txt")]
(-> (.read f) (.strip) (.replace "\"" "") (.split ",") (diurutkan))))

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

;; Mungkin bukan ide yang bagus
(kotak defn? [x]
(->> 2 (pow (int (sqrt x))) (= x)))

· Notasi titik gaya-clojure lebih disukai daripada panggilan langsung metode objek,
meskipun keduanya akan terus didukung.

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

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

Kesimpulan
“Mode memudar, gaya abadi” —Yves Saint Laurent

Panduan ini hanyalah seperangkat pedoman komunitas, dan tentu saja, pedoman komunitas berfungsi
tidak masuk akal tanpa komunitas yang aktif. Kontribusi dipersilakan. Bergabunglah bersama kami di #hy in
freenode, blog tentang itu, tweet tentang itu, dan yang paling penting, bersenang-senanglah dengan Hy.

Terima kasih
· Panduan ini sangat terinspirasi dari @paultag posting blog Hy Kelangsungan hidup Panduan

· Itu Clojure Gaya Panduan

DOKUMENTASI INDEKS

Isi:

perintah baris Antarmuka
hy
perintah baris Opsi
-c
Jalankan kode Hy di Command.

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

-i
Jalankan kode Hy di Command, lalu tetap di REPL.

-m
Jalankan kode Hy di modul, termasuk defmain jika didefinisikan.

Grafik -m flag mengakhiri daftar opsi sehingga semua argumen setelah modul nama
diteruskan ke modul di sys.argv.

Baru di versi 0.10.2.

--mengintai Cetak kode Python yang setara sebelum dieksekusi. Sebagai contoh:

=> (defn salamationsnm [nama] (cetak (+ "Hy " nama "!")))
def salamsnm(nama):
kembali print(((u'Hy ' + nama) + u'!'))
=> (salutationsnm "Nama Anda")
salutationsnm(u'NamaAnda')
Hy Nama Anda!
=>

Baru di versi 0.9.11.

--show-traceback
Cetak traceback yang diperluas untuk pengecualian Hy.

Baru di versi 0.9.12.

-v Cetak nomor versi Hy dan keluar.

hyc
perintah baris Opsi
mengajukan[, fileN]
Kompilasi kode Hy ke bytecode Python. Misalnya, simpan kode berikut sebagai
hyname.hy:

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

(hy-hy "Afroman")

Lalu lari:

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

hy2py
Baru di versi 0.10.1.

perintah baris Opsi
-s

--dengan-sumber
Tampilkan struktur sumber yang diurai.

-a

--dengan-ast
Tampilkan AST yang dihasilkan.

-misalnya

--tanpa-python
Jangan tampilkan kode Python yang dihasilkan dari AST.

Hy (The bahasa)
PERINGATAN:
Ini tidak lengkap; harap pertimbangkan untuk berkontribusi pada upaya dokumentasi.

Teori of Hy
Hy mempertahankan, di atas segalanya, kompatibilitas 100% di kedua arah dengan Python
diri. Semua kode Hy mengikuti beberapa aturan sederhana. Hafalkan ini, karena akan masuk
berguna.

Aturan ini membantu memastikan bahwa kode Hy bersifat idiomatis dan dapat digunakan dalam kedua bahasa.

· Simbol di penutup telinga akan diterjemahkan ke versi huruf besar dari string itu. Untuk
contoh, foo akan menjadi FOO.

· Entitas UTF-8 akan dikodekan menggunakan punycode.dll dan diawali dengan hy_. Contohnya, ⚘
akan menjadi hy_w7h, ♥ akan menjadi hy_g6h, dan aku♥kamu akan menjadi hy_iu_t0x.

· Simbol yang mengandung tanda hubung akan diganti dengan garis bawah. Sebagai contoh,
render-templat akan menjadi render_template. Ini berarti bahwa simbol dengan tanda hubung akan
bayangan padanan garis bawahnya, dan sebaliknya.

Built-In
Hy menampilkan sejumlah formulir khusus yang digunakan untuk membantu menghasilkan AST Python yang benar.
Berikut ini adalah formulir "khusus", yang mungkin memiliki perilaku yang sedikit tidak terduga dalam
beberapa situasi.

.
Baru di versi 0.10.0.

. digunakan untuk melakukan akses atribut pada objek. Ini menggunakan DSL kecil untuk memungkinkan cepat
akses ke atribut dan item dalam struktur data bersarang.

Misalnya,

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

Dikompilasi ke:

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

. mengkompilasi argumen pertamanya (dalam contoh, foo) sebagai objek untuk melakukan
dereferensi atribut. Ini menggunakan simbol telanjang sebagai atribut untuk mengakses (dalam contoh, bar,
dasar, katak), dan mengkompilasi konten daftar (dalam contoh, [(+ 1 2)]) untuk indeksasi.
Argumen lain menimbulkan kesalahan kompilasi.

Akses ke atribut yang tidak dikenal melempar AtributError. Akses ke kunci yang tidak dikenal melempar
Kesalahan Indeks (pada daftar dan tupel) atau a Kesalahan Kunci (pada kamus).

->
-> (Atau threading makro) digunakan untuk menghindari bersarangnya ekspresi. makro threading
menyisipkan setiap ekspresi ke tempat argumen pertama ekspresi berikutnya. Pengikut
kode menunjukkan ini:

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

- >>
- >> (Atau threading ekor makro) mirip dengan threading makro, tetapi alih-alih
memasukkan setiap ekspresi ke dalam argumen pertama ekspresi berikutnya, itu menambahkannya sebagai
argumen terakhir. Kode berikut menunjukkan ini:

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

menerapkan
menerapkan digunakan untuk menerapkan daftar argumen opsional dan kamus opsional kwargs
ke suatu fungsi.

Pemakaian: (berlaku nama-fn [argumen] [kwarg])

contoh:

(pasti terima kasih []
"hai disana")

(terapkan thunk)
;=> "hai"

(defn total pembelian [jumlah harga & opsional [biaya 1.05] [PPN 1.1]]
(* harga jumlah biaya PPN))

(terapkan total pembelian [10 15])
;=> 173.25

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

(terapkan total pembelian [] {"price" 10 "amount" 15 "vat" 1.05})
;=> 165.375

dan
dan digunakan dalam ekspresi logika. Dibutuhkan setidaknya dua parameter. Jika semua parameter
mengevaluasi untuk Benar, parameter terakhir dikembalikan. Dalam kasus lain, nilai salah pertama
akan dikembalikan. Contoh penggunaan:

=> (dan Benar Salah)
Salah

=> (dan Benar Benar)
Benar

=> (dan Benar 1)
1

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

CATATAN:
dan hubungan arus pendek dan berhenti mengevaluasi parameter segera setelah kesalahan pertama adalah
ditemui.

=> (dan Salah (cetak "halo"))
Salah

menegaskan
menegaskan digunakan untuk memverifikasi kondisi saat program sedang berjalan. Jika kondisi tidak
bertemu, dan PernyataanError diangkat. menegaskan dapat mengambil satu atau dua parameter. Pertama
parameter adalah kondisi yang harus diperiksa, dan itu harus dievaluasi menjadi Benar or Salah. itu
parameter kedua, opsional, adalah label untuk pernyataan, dan merupakan string yang akan
dibesarkan dengan PernyataanError. Sebagai contoh:

(tegaskan (= variabel nilai yang diharapkan))

(tegaskan Salah)
; PernyataanError

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

Assoc
Assoc digunakan untuk mengaitkan kunci dengan nilai dalam kamus atau untuk mengatur indeks daftar
ke suatu nilai. Dibutuhkan setidaknya tiga parameter: the data struktur untuk diubah, a kunci
or indeks, Dan nilai. Jika lebih dari tiga parameter yang digunakan, itu akan mengasosiasikan berpasangan.

Contoh penggunaan:

=>(biarkan [[koleksi {}]]
... (koleksi assoc "Anjing" "Bark")
... (koleksi cetak))
{u'Anjing': u'Bark'}

=>(biarkan [[koleksi {}]]
... (koleksi assoc "Anjing" "Kulit" "Kucing" "Meong")
... (koleksi cetak))
{u'Cat': u'Meow', u'Dog': u'Bark'}

=>(biarkan [[koleksi [1 2 3 4]]]
... (koleksi assoc 2 Tidak ada)
... (koleksi cetak))
[1, 2, Tidak Ada, 4]

CATATAN:
Assoc memodifikasi struktur data di tempat dan mengembalikan None.

istirahat
istirahat digunakan untuk keluar dari loop. Ini mengakhiri loop segera. Pengikut
contoh memiliki tak terbatas sementara loop yang dihentikan segera setelah pengguna masuk k.

(sementara Benar (jika (= "k" (masukan mentah "? "))
(merusak)
(cetak "Coba lagi")))

cond
cond dapat digunakan untuk membangun bersarang if pernyataan. Contoh berikut menunjukkan
hubungan antara makro dan ekspansinya:

(kondisi [kondisi-1 hasil-1]
[kondisi-2 hasil-2])

(jika kondisi-1 hasil-1
(jika kondisi-2 hasil-2))

Seperti yang ditunjukkan di bawah ini, hanya blok hasil pencocokan pertama yang dieksekusi.

=> (nilai cek defn [nilai]
... (cond [(< nilai 5) (cetak "nilai lebih kecil dari 5")]
... [(= nilai 5) (cetak "nilai sama dengan 5")]
... [(> nilai 5) (cetak "nilai lebih besar dari 5")]
... [Benar (cetak "nilai adalah sesuatu yang tidak seharusnya")]))

=> (nilai cek 6)
nilainya lebih besar dari 5

terus
terus mengembalikan eksekusi ke awal loop. Dalam contoh berikut,
(efek samping1) dipanggil untuk setiap iterasi. (efek samping2), bagaimanapun, hanya dipanggil
setiap nilai lain dalam daftar.

;; dengan asumsi bahwa (efek samping1) dan (efek samping2) adalah fungsi dan
;; koleksi adalah daftar nilai numerik

(untuk [koleksi x]
(melakukan
(efek samping1 x)
(jika (% x 2)
(melanjutkan))
(efek samping2 x)))

dict-com
dict-com digunakan untuk membuat kamus. Dibutuhkan tiga atau empat parameter. Pertama
dua parameter untuk mengontrol nilai balik (pasangan nilai kunci) sedangkan yang ketiga adalah
digunakan untuk memilih item dari urutan. Parameter keempat dan opsional dapat digunakan untuk
menyaring beberapa item dalam urutan berdasarkan ekspresi bersyarat.

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

do / prog
do dan prog digunakan untuk mengevaluasi setiap argumen mereka dan mengembalikan yang terakhir. Kembali
nilai dari setiap selain argumen terakhir dibuang. Ini dapat digunakan dalam lambda or
daftar-komp untuk melakukan logika yang lebih kompleks seperti yang ditunjukkan pada salah satu contoh berikut.

Beberapa contoh penggunaan:

=> (jika benar
... (lakukan (cetak "Efek samping rock!")
... (cetak "Ya, sungguh!")))
Efek samping batu!
Ya, benar-benar!

;; dengan asumsi bahwa (efek samping) adalah fungsi yang ingin kita panggil untuk masing-masing
;; dan setiap nilai dalam daftar, tetapi nilai pengembaliannya tidak kami pedulikan
=> (daftar-comp (lakukan (efek samping x)
... (jika (< x 5) (* 2 x)
... (* 4x))))
... (x (kisaran 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do dapat menerima sejumlah argumen, dari 1 hingga n.

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

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

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

defclass
Kelas baru dideklarasikan dengan defclass. Dibutuhkan dua parameter opsional: vektor
mendefinisikan kelas super yang mungkin dan vektor lain yang berisi atribut dari yang baru
kelas sebagai dua vektor item.

(nama kelas defclass [kelas super-1 kelas super-2]
[[nilai atribut]])

Baik nilai dan fungsi dapat diikat pada kelas baru seperti yang ditunjukkan oleh contoh di bawah ini:

=> (defclass Kucing []
... [[usia Tidak Ada]
... [warna "putih"]
... [bicara (fn [self] (cetak "Meow"))]])

=> (titik def (Kucing))
=> (setv spot.color "Hitam")
'Hitam'
=> (.speak spot)
meong

defn / tidak menyenangkan
defn dan tidak menyenangkan macro digunakan untuk mendefinisikan fungsi. Mereka mengambil tiga parameter: the nama
dari fungsi untuk mendefinisikan, vektor dari parameter, Dan tubuh dari fungsi:

(nama defn [params] body)

Parameter mungkin memiliki kata kunci berikut di depannya:

&opsional
Parameter adalah opsional. Parameter dapat diberikan sebagai daftar dua item, di mana
elemen pertama adalah nama parameter dan yang kedua adalah nilai default. Parameternya
dapat juga diberikan sebagai satu item, dalam hal ini nilai defaultnya adalah None.

=> (defn nilai total [nilai & opsional [pajak pertambahan nilai 10]]
... (+ (/ (* nilai pajak pertambahan nilai) 100) nilai))

=> (nilai total 100)
110.0

=> (nilai total 100 1)
101.0

&kunci

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

Contoh kode berikut mendefinisikan fungsi yang akan mencetak semua kata kunci
argumen dan nilai-nilainya.

=> (parameter cetak defn [&kwargs kwargs]
... (untuk [(, kv) (.items kwargs)] (cetak kv))))

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

&istirahat Parameter akan berisi 0 atau lebih argumen posisi. Tidak ada posisi lain
argumen dapat ditentukan setelah ini.

Contoh kode berikut mendefinisikan fungsi yang dapat diberikan 0 hingga n numerik
parameter. Kemudian jumlahkan setiap bilangan ganjil dan kurangi setiap bilangan genap.

=> (defn zig-zag-sum [&nomor istirahat]
(biarkan [[angka ganjil (daftar-kompilasi x [angka x] (ganjil? x))]
[bilangan genap (daftar-comp x [angka x] (genap? x))]]
(- (jumlah bilangan ganjil) (jumlah bilangan genap))))

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

Grafik defn-alias dan defun-alias makro sangat mirip defn, dengan perbedaan bahwa
alih-alih mendefinisikan fungsi dengan satu nama, ini juga dapat mendefinisikan alias. Lainnya
daripada mengambil daftar simbol untuk nama fungsi sebagai parameter pertama, defn-alias dan
defun-alias tidak berbeda dengan defn dan tidak menyenangkan.

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

defmain
Baru di versi 0.10.1.

Grafik defmain makro mendefinisikan fungsi utama yang segera dipanggil dengan sys.argv as
argumen jika dan hanya jika file ini dieksekusi sebagai skrip. Dengan kata lain, ini:

(definisikan [&rest args]
(lakukan-sesuatu-dengan argumen))

adalah setara dengan:

def utama(*argumen):
lakukan_sesuatu_dengan(args)
kembalikan 0

jika __name__ == "__main__":
impor sys
retval = main(*sys.arg)

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

Perhatikan bahwa seperti yang Anda lihat di atas, jika Anda mengembalikan bilangan bulat dari fungsi ini, ini akan menjadi
digunakan sebagai status keluar untuk skrip Anda. (Python default untuk keluar dari status 0 jika tidak,
yang berarti semuanya baik-baik saja!)

(Sejak (sys.keluar 0) tidak dijalankan secara eksplisit dalam kasus pengembalian non-integer dari
defmain, itu ide yang baik untuk menempatkan (mendefinisikan) sebagai bagian terakhir dari kode dalam file Anda.)

defmakro
defmakro digunakan untuk mendefinisikan makro. Bentuk umumnya adalah (defmakro nama [parameter]
ekspr).

Contoh berikut mendefinisikan makro yang dapat digunakan untuk menukar urutan elemen dalam kode,
memungkinkan pengguna untuk menulis kode dalam notasi infiks, di mana operator berada di antara
operan.

=> (defmacro infix [kode]
... (kutipan semu (
... (tanda kutip (dapatkan kode 1))
... (tanda kutip (dapatkan kode 0))
... (tanda kutip (dapatkan kode 2)))))

=> (infiks (1 + 1))
2

alias defmakro
alias defmakro digunakan untuk mendefinisikan makro dengan beberapa nama (alias). Format umum
is (alias defmakro [nama] [parameter] ekspr). Ini menciptakan beberapa makro dengan yang sama
daftar parameter dan isi, di bawah daftar nama yang ditentukan.

Contoh berikut mendefinisikan dua makro, keduanya memungkinkan pengguna untuk menulis kode dalam
notasi infiks.

=> (defmacro-alias [infix infi] [kode]
... (kutipan semu (
... (tanda kutip (dapatkan kode 1))
... (tanda kutip (dapatkan kode 0))
... (tanda kutip (dapatkan kode 2)))))

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

defmakro/g!
Baru di versi 0.9.12.

defmakro/g! adalah versi khusus dari defmakro yang digunakan untuk menghasilkan secara otomatis gensym
untuk setiap simbol yang dimulai dengan g!.

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

SEE JUGA:
Bagian menggunakan-gensym

defreader
Baru di versi 0.9.12.

defreader mendefinisikan makro pembaca, memungkinkan Anda untuk merestrukturisasi atau memodifikasi sintaks.

=> (defreader ^ [expr] (cetak expr))
=> #^(1 2 3 4)
(1)
=> #^"Halo"
"Halo"

SEE JUGA:
Makro Pembaca Bagian

itu
Baru di versi 0.9.12.

itu menghapus objek dari namespace saat ini.

=> (setv untuk 42)
=> (del foo)
=> foo
Traceback (panggilan terakhir terakhir):
berkas " ", baris 1, di
NameError: nama 'foo' tidak ditentukan

itu juga dapat menghapus objek dari pemetaan, daftar, dan lainnya.

=> (pengujian setv (daftar (rentang 10))))
=> tes
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (del (tes irisan 2 4)) ;; hapus item dari 2 hingga 4 dikecualikan
=> tes
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "bar"})
=> dic
{"foo": "bar"}
=> (del (dapatkan dic "foo"))
=> dic
{}

lakukan untuk
Baru di versi 0.10.1.

lakukan untuk digunakan untuk menyederhanakan urutan pemanggilan metode ke suatu objek.

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

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

evaluasi
evaluasi mengevaluasi ekspresi yang dikutip dan mengembalikan nilainya.

=> (eval '(cetak "Halo Dunia"))
"Halo Dunia"

evaluasi-dan-kompilasi
evaluasi-ketika-kompilasi
pertama / mobil
pertama dan mobil adalah makro untuk mengakses elemen pertama koleksi:

=> (pertama (rentang 10))
0

untuk
untuk digunakan untuk memanggil fungsi untuk setiap elemen dalam daftar atau vektor. Hasil masing-masing
panggilan dibuang dan untuk ekspresi kembali None sebagai gantinya. Contoh kode berulang
lebih koleksi dan untuk masing-masing elemen in koleksi memanggil efek samping berfungsi dengan
elemen sebagai argumennya:

;; dengan asumsi bahwa (efek samping) adalah fungsi yang mengambil parameter tunggal
(untuk [koleksi elemen] (elemen efek samping))

;; untuk dapat memiliki blok else opsional
(untuk [koleksi elemen] (elemen efek samping)
(lainnya (efek samping-2)))

Opsional lain blok hanya dieksekusi jika untuk loop berakhir secara normal. jika
eksekusi dihentikan dengan istirahat, yang lain blok tidak dieksekusi.

=> (untuk [elemen [1 2 3]] (jika (< elemen 3)
... (elemen cetak)
... (merusak))
... (else (cetak "loop selesai")))
1
2

=> (untuk [elemen [1 2 3]] (jika (< elemen 4)
... (elemen cetak)
... (merusak))
... (else (cetak "loop selesai")))
1
2
3
lingkaran selesai

genexpr
genexpr digunakan untuk membuat ekspresi generator. Dibutuhkan dua atau tiga parameter. NS
parameter pertama adalah ekspresi yang mengontrol nilai kembalian, sedangkan yang kedua digunakan
untuk memilih item dari daftar. Parameter ketiga dan opsional dapat digunakan untuk menyaring
beberapa item dalam daftar berdasarkan ekspresi bersyarat. genexpr mirip dengan
daftar-komp, kecuali mengembalikan iterable yang mengevaluasi nilai satu per satu alih-alih
mengevaluasi mereka segera.

=> (kumpulan def (kisaran 10))
=> (def difilter (genexpr x [x koleksi] (genap? x)))
=> (daftar difilter)
[0, 2, 4, 6, 8]

gensym
Baru di versi 0.9.12.

gensym digunakan untuk menghasilkan simbol unik yang memungkinkan makro ditulis tanpa
bentrokan nama variabel yang tidak disengaja.

=> (gensim)
kamu':G_1235'

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

SEE JUGA:
Bagian menggunakan-gensym

mendapatkan
mendapatkan digunakan untuk mengakses elemen tunggal dalam daftar dan kamus. mendapatkan membutuhkan dua parameter:
itu data struktur dan indeks or kunci dari barang tersebut. Kemudian akan mengembalikan yang sesuai
nilai dari kamus atau daftar. Contoh penggunaan:

=> (biarkan [[binatang {"anjing" "menggonggong" "kucing" "meong"}]
... [angka ["nol" "satu" "dua" "tiga"]]]
... (cetak (dapatkan hewan "anjing"))
... (cetak (dapatkan nomor 2)))
kulit
dua

CATATAN:
mendapatkan memunculkan KeyError jika kamus ditanyai untuk kunci yang tidak ada.

CATATAN:
mendapatkan memunculkan IndexError jika daftar atau tupel ditanyai untuk indeks yang keluar dari
batas.

global
global dapat digunakan untuk menandai simbol sebagai global. Hal ini memungkinkan programmer untuk menetapkan
nilai ke simbol global. Membaca simbol global tidak memerlukan global kata kunci --
hanya menetapkan itu tidak.

Contoh berikut menunjukkan bagaimana simbol global a diberi nilai dalam suatu fungsi dan
nanti dicetak di fungsi lain. Tanpa global kata kunci, fungsi kedua
akan melempar NamaKesalahan.

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

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

(atur-a 5)
(cetak-a)

if / jika tidak
Baru di versi 0.10.0: jika-tidak

if digunakan untuk memilih kode yang akan dieksekusi secara kondisional. Itu harus mengandung suatu kondisi
blok dan blok yang akan dieksekusi jika blok kondisi mengevaluasi ke Benar. Opsional,
itu mungkin berisi blok terakhir yang dieksekusi jika evaluasi kondisinya adalah
Salah.

jika tidak serupa, tetapi blok kedua akan dieksekusi ketika kondisi gagal saat
blok ketiga dan terakhir dijalankan ketika tes berhasil -- urutan kebalikan dari if.

Contoh penggunaan:

(jika (rekening sisa uang?)
(cetak "ayo belanja")
(cetak "ayo pergi dan bekerja"))

(jika-tidak (rekening sisa uang?)
(cetak "ayo pergi dan bekerja")
(cetak "ayo belanja"))

Kebenaran Python dihormati. None, Salah, nol dari semua jenis numerik, urutan kosong,
dan kamus kosong dianggap Salah; segala sesuatu yang lain dianggap Benar.

cadel-jika / hidup dan cadel-jika-tidak / hidup-tidak
Baru di versi 0.10.0.

Baru di versi 0.10.2: lisp-if-not / lif-not

Bagi mereka yang lebih menyukai Lispy if klausa, kita punya cadel-jika, atau hidup. Ini hanya menganggap
None / nol menjadi palsu! Semua nilai Python "false-ish" lainnya dianggap benar.
Sebaliknya, kita memiliki cadel-jika-tidak dan hidup-tidak sejajar dengan if dan jika tidak yang membalikkan
perbandingan.

=> (cadel-jika Benar "benar" "salah")
"Benar"
=> (cadel-jika Salah "benar" "salah")
"Benar"
=> (cadel-jika 0 "benar" "salah")
"Benar"
=> (cadel-jika nil "benar" "salah")
"Salah"
=> (cadel-jika Tidak ada "benar" "salah")
"Salah"
=> (cadel-jika-tidak nil "benar" "salah")
"Benar"
=> (cadel-jika-tidak Tidak ada "benar" "salah")
"Benar"
=> (cadel-jika-tidak Salah "benar" "salah")
"Salah"

; Setara tapi lebih pendek
=> (jika Benar "benar" "salah")
"Benar"
=> (jika nihil "benar" "salah")
"Salah"
=> (lif-not None "benar" "salah")
"Benar"

mengimpor
mengimpor digunakan untuk mengimpor modul, seperti di Python. Ada beberapa cara yang mengimpor bisa
digunakan.

;; Impor masing-masing modul ini
;;
;; ular piton:
;; sistem impor
;; impor os.path
(impor sys os.path)

;; Impor dari modul
;;
;; Python: dari os.path impor ada, isdir, isfile
(import [os.path [ada isdir isfile]])

;; Impor dengan alias
;;
;; Python: impor sys sebagai systest
(impor [sys : sebagai systest])

;; Anda dapat membuat daftar impor sebanyak yang Anda suka dari berbagai jenis.
(impor [tests.resources [kwtest function-with-a-dash]]
[os.path [ada isdir isfile]]
[sys :sebagai systest])

;; Impor semua fungsi modul ke namespace saat ini
(impor [sistem [*]])

lambda / fn
lambda dan fn dapat digunakan untuk mendefinisikan fungsi anonim. Parameternya mirip dengan
defn: parameter pertama adalah vektor parameter dan sisanya adalah badan dari
fungsi. lambda mengembalikan fungsi baru. Dalam contoh berikut, fungsi anonim
didefinisikan dan diteruskan ke fungsi lain untuk menyaring keluaran.

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

=> (defn display-people [filter orang]
... (untuk [orang orang] (jika (penyaring orang) (cetak (:nama orang)))))

=> (menampilkan orang-orang (fn [orang] (< (:usia orang) 25)))
Alice
Dave

Sama seperti dalam definisi fungsi normal, jika elemen pertama dari tubuh adalah string, itu
berfungsi sebagai docstring. Ini berguna untuk memberikan docstrings metode kelas.

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

Ini dapat dikonfirmasi melalui built-in Python membantu fungsi:

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

kali_tiga(x)
Mengalikan input dengan tiga dan mengembalikan hasil
(AKHIR)

terakhir
Baru di versi 0.10.2.

terakhir dapat digunakan untuk mengakses elemen terakhir dari koleksi:

=> (terakhir [2 4 6])
6

membiarkan
membiarkan digunakan untuk membuat variabel cakupan leksikal. Mereka dibuat di awal
membiarkan bentuk dan tidak ada lagi setelah bentuk. Contoh berikut menunjukkan ini
perilaku:

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

Grafik membiarkan makro membutuhkan dua parameter: pendefinisian vektor variabel dan tubuh yang mendapat
dieksekusi. variabel adalah vektor di mana setiap elemen adalah variabel tunggal atau vektor
mendefinisikan pasangan nilai variabel. Dalam kasus variabel tunggal, itu diberi nilai
None; jika tidak, nilai yang diberikan akan digunakan.

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

daftar-komp
daftar-komp melakukan pemahaman daftar. Dibutuhkan dua atau tiga parameter. Pertama
parameter adalah ekspresi yang mengontrol nilai kembalian, sedangkan yang kedua digunakan untuk
pilih item dari daftar. Parameter ketiga dan opsional dapat digunakan untuk menyaring beberapa
item dalam daftar berdasarkan ekspresi bersyarat. Beberapa contoh:

=> (kumpulan def (kisaran 10))
=> (daftar-kompilasi x [koleksi x])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

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

tidak
tidak digunakan dalam ekspresi logika. Dibutuhkan satu parameter dan mengembalikan yang terbalik
nilai kebenaran. Jika Benar diberikan sebagai parameter, Salah akan dikembalikan, begitu pula sebaliknya.
Contoh penggunaan:

=> (tidak Benar)
Salah

=> (tidak Salah)
Benar

=> (bukan Tidak Ada)
Benar

or
or digunakan dalam ekspresi logika. Dibutuhkan setidaknya dua parameter. Ini akan mengembalikan
parameter tidak salah pertama. Jika tidak ada nilai seperti itu, parameter terakhir akan dikembalikan.

=> (atau Benar Salah)
Benar

=> (dan Salah Salah)
Salah

=> (dan Salah 1 Benar Salah)
1

CATATAN:
or hubungan arus pendek dan berhenti mengevaluasi parameter segera setelah nilai benar pertama adalah
ditemui.

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

mencetak
mencetak digunakan untuk menampilkan di layar. Contoh penggunaan:

(cetak "Halo dunia!")

CATATAN:
mencetak selalu kembali None.

kutipan semu
kutipan semu memungkinkan Anda untuk mengutip formulir, tetapi juga mengevaluasi ekspresi secara selektif.
Ekspresi di dalam a kutipan semu dapat dievaluasi secara selektif menggunakan tanda kutip (~). Itu
bentuk yang dievaluasi juga dapat disambung menggunakan tanda kutip-sambatan (~@). Kuasi kutip bisa juga
ditulis menggunakan backquote (`) simbol.

;; biarkan `qux' menjadi variabel dengan nilai (bar baz)
`(foo ~qux)
; setara dengan '(foo (bar baz))
`(foo ~@qux)
; setara dengan '(foo bar baz)

mengutip
mengutip mengembalikan formulir yang diteruskan ke sana tanpa mengevaluasinya. mengutip bisa juga
ditulis dengan menggunakan tanda kutip (') simbol.

=> (setv x '(cetak "Halo Dunia"))
; variabel x diatur ke ekspresi & tidak dievaluasi
=> x
(u'print' u'Hello World')
=> (nilai x)
Hello Dunia

membutuhkan
membutuhkan digunakan untuk mengimpor makro dari modul tertentu. Dibutuhkan setidaknya satu parameter
menentukan modul makro mana yang harus diimpor. Beberapa modul dapat diimpor
dengan satu membutuhkan.

Contoh berikut akan mengimpor makro dari modul 1 dan modul 2:

(memerlukan modul-1 modul-2)

istirahat / cdr
istirahat dan cdr kembalikan koleksi yang diteruskan sebagai argumen tanpa elemen pertama:

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

set-komp
set-komp digunakan untuk membuat himpunan. Dibutuhkan dua atau tiga parameter. Parameter pertama adalah
untuk mengontrol nilai pengembalian, sedangkan yang kedua digunakan untuk memilih item dari a
urutan. Parameter ketiga dan opsional dapat digunakan untuk menyaring beberapa item di
urutan berdasarkan ekspresi kondisional.

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

mengiris
mengiris dapat digunakan untuk mengambil subset dari daftar dan membuat daftar baru darinya. Formulir
membutuhkan setidaknya satu parameter yang menentukan daftar untuk diiris. Dua parameter opsional dapat:
digunakan untuk memberikan posisi awal dan akhir dari subset. Jika tidak disediakan,
nilai default dari None akan digunakan sebagai gantinya. Parameter opsional ketiga digunakan untuk
langkah kontrol antar elemen.

mengiris mengikuti aturan yang sama dengan rekan Python-nya. Indeks negatif dihitung
mulai dari akhir daftar. Beberapa contoh penggunaan:

=> (kumpulan def (kisaran 10))

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

=> (kumpulan irisan 5)
[5, 6, 7, 8, 9]

=> (kumpulan irisan 2 8)
[2, 3, 4, 5, 6, 7]

=> (kumpulan irisan 2 8 2)
[2, 4, 6]

=> (kumpulan irisan -4 -2)
[6, 7]

melemparkan / menaikkan
Grafik melemparkan or menaikkan formulir dapat digunakan untuk menaikkan Pengecualian saat berjalan. Contoh penggunaan:

(melemparkan)
; re-rase pengecualian terakhir

(lempar IOError)
; Lempar IOError

(lempar (IOError "foobar"))
; Lempar IOError("foobar")

melemparkan dapat menerima satu argumen (an Pengecualian kelas atau instance) atau tidak ada argumen untuk
membangkitkan kembali yang terakhir Pengecualian.

mencoba
Grafik mencoba form digunakan untuk memulai mencoba / menangkap memblokir. Bentuk yang digunakan sebagai berikut:

(mencoba
(fungsi rawan kesalahan)
(tangkap [e ZeroDivisionError] (cetak "Pembagian dengan nol"))
(lainnya (cetak "tidak ada kesalahan"))
(akhirnya (cetak "semua selesai")))

mencoba harus mengandung setidaknya satu menangkap blok, dan secara opsional dapat menyertakan lain or akhirnya
memblokir. Jika kesalahan dimunculkan dengan blok tangkapan yang cocok selama eksekusi
fungsi rawan kesalahan, Bahwa menangkap blok akan dieksekusi. Jika tidak ada kesalahan yang muncul, lain
blok dieksekusi. Itu akhirnya blok akan dieksekusi terakhir terlepas dari apakah atau tidak
kesalahan diangkat.

kecuali kalau
Grafik kecuali kalau makro adalah singkatan untuk menulis dan if pernyataan yang memeriksa apakah diberikan
bersyarat adalah Salah. Berikut ini adalah perluasan dari makro ini.

(kecuali pernyataan bersyarat)

(jika bersyarat
None
(lakukan pernyataan))

tanda kutip
Dalam bentuk quasiquoted, tanda kutip memaksa evaluasi simbol. tanda kutip alias
air pasang (~) simbol.

(nama pasti "Cuddles")
(kuasi kutip (= nama (nama tanpa tanda kutip)))
;=> (u'=' u'name' u'Cuddles')

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

tanda kutip-sambatan
tanda kutip-sambatan memaksa evaluasi simbol dalam bentuk quasiquoted, seperti
tanda kutip. tanda kutip-sambatan hanya dapat digunakan ketika simbol yang tidak dikutip mengandung
nilai yang dapat diubah, karena "menyambung" yang dapat diubah ke dalam bentuk quasiquoted. tanda kutip-sambatan is
alias untuk ~@ simbol.

(angka pasti [1 2 3 4])
(kuasi kutip (+ (angka sambungan tanda kutip))))
;=> (u'+' 1L 2L 3L 4L)

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

ketika
ketika mirip dengan kecuali kalau, kecuali itu menguji ketika kondisional yang diberikan adalah Benar. Bukan itu
mungkin untuk memiliki lain blok di ketika makro. Berikut ini adalah perluasan dari
makro.

(ketika pernyataan bersyarat)

(jika bersyarat (pernyataan do))

sementara
sementara digunakan untuk mengeksekusi satu atau lebih blok selama kondisi terpenuhi. Pengikut
contoh akan menampilkan "Halo dunia!" ke layar tanpa batas:

(sementara True (cetak "Halo dunia!"))

dengan
dengan digunakan untuk membungkus eksekusi blok dalam manajer konteks. Isi
manajer kemudian dapat mengatur sistem lokal dan meruntuhkannya dengan cara yang terkendali. Itu
contoh pola dasar penggunaan dengan adalah saat memproses file. dengan dapat mengikat konteks ke
argumen atau mengabaikannya sama sekali, seperti yang ditunjukkan di bawah ini:

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

(dengan blok [[(expr)]])

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

Contoh berikut akan membuka BERITA（NEWS） file dan mencetak isinya ke layar. Itu
file secara otomatis ditutup setelah diproses.

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

dengan-dekorator
dengan-dekorator digunakan untuk membungkus suatu fungsi dengan yang lain. Fungsi yang melakukan
dekorasi harus menerima satu nilai: fungsi yang didekorasi, dan mengembalikan yang baru
fungsi. dengan-dekorator membutuhkan minimal dua parameter: kinerja fungsi
dekorasi dan fungsi yang dihias. Lebih dari satu fungsi dekorator dapat
terapan; mereka akan diterapkan dalam urutan dari terluar ke terdalam, yaitu. pertama
dekorator akan menjadi yang terluar, dan seterusnya. Dekorator dengan argumen disebut adil
seperti panggilan fungsi.

(dengan-dekorator dekorator-menyenangkan
(defn beberapa-fungsi [] ...)

(dengan-dekorator dekorator1 dekorator2 ...
(defn beberapa-fungsi [] ...)

(dengan dekorator (dekorator arg) ..
(defn beberapa-fungsi [] ...)

Dalam contoh berikut, inc-dekorator digunakan untuk mendekorasi fungsi tambahan dengan
fungsi yang mengambil dua parameter dan memanggil fungsi yang didekorasi dengan nilai-nilai yang
bertambah 1. Saat dihias tambahan disebut dengan nilai 1 dan 1, ujungnya
hasilnya 4 (1 + 1 + 1 + 1).

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

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

dengan-gensyms
Baru di versi 0.9.12.

dengan-gensym digunakan untuk menghasilkan satu set gensym untuk digunakan dalam makro. Kode berikut:

(dengan-gensyms [abc]
...)

berkembang menjadi:

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

SEE JUGA:
Bagian menggunakan-gensym

menghasilkan
menghasilkan digunakan untuk membuat objek generator yang mengembalikan satu atau lebih nilai. generatornya
dapat diubah dan karenanya dapat digunakan dalam perulangan, pemahaman daftar, dan lainnya yang serupa
konstruksi.

Fungsi angka acak menunjukkan bagaimana generator dapat digunakan untuk menghasilkan seri tak terbatas
tanpa menghabiskan jumlah memori yang tak terbatas.

=> (defn kalikan [koefisien basis]
... (untuk [[(, koefisien dasar) (koefisien basis zip)]]
... (hasil (* koefisien dasar)))))

=> (kalikan (kisaran 5) (kisaran 5))


=> (nilai daftar-comp [nilai (kalikan (kisaran 10) (kisaran 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (impor secara acak)
=> (defn angka acak [rendah tinggi]
... (sementara True (yield (.randint random low high))))
=> (daftar-comp x [x (ambil 15 (angka-acak 1 50))])])
[7, 41, 6, 22, 32, 17, 5, 38, 18, 38, 17, 14, 23, 23, 19]

hasil-dari
Baru di versi 0.9.13.

PYTHON 3.3 DAN UP HANYA!

hasil-dari digunakan untuk memanggil subgenerator. Ini berguna jika Anda ingin coroutine Anda
dapat mendelegasikan prosesnya ke coroutine lain, katakanlah, jika menggunakan sesuatu yang mewah seperti
asincio.

Hy Core
Core Fungsi
terakhir
Pemakaian: (but terakhir col)

Mengembalikan iterator dari semua kecuali item terakhir di coll.

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

=> (daftar (butterakhir [1]))
[]

=> (daftar (butterakhir []))
[]

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

kol?
Baru di versi 0.10.0.

Pemakaian: (kol? x)

Pengembalian Benar if x dapat diubah dan bukan string.

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

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

=> (kolom? "abc")
Salah

kontra
Baru di versi 0.10.0.

Pemakaian: (kontra a b)

Mengembalikan sel kontra baru dengan mobil a dan cdr b.

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

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

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

kontra?
Baru di versi 0.10.0.

Pemakaian: (kontra? foo)

Memeriksa apakah foo adalah sel kontra.

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

=> (kontra? a)
Benar

=> (kontra? nihil)
Salah

=> (kontra? [1 2 3])
Salah

Desember
Pemakaian: (Desember x)

Mengembalikan satu kurang dari x. Setara dengan (- x 1). meningkatkan KetikError if (Tidak (numerik? X)).

=> (Des 3)
2

=> (Des 0)
-1

=> (Des 12.3)
11.3

membongkar
Baru di versi 0.10.0.

Pemakaian: (membongkar pohon &opsional [kodegen Salah])

Buang AST Python untuk Hy . yang diberikan pohon ke keluaran standar. Jika kodegen is Benar, fungsi
mencetak kode Python sebagai gantinya.

=> (bongkar '(cetak "Halo Dunia!"))
Modul(
tubuh=[
Expr(value=Call(func=Name(id='print'), args=[Str(s='Hello World!')], keywords=[], starargs=None, kwargs=None))])

=> (bongkar '(cetak "Halo Dunia!") benar)
print('Halo Dunia!')

kosong?
Pemakaian: (kosong? col)

Pengembalian Benar if coll kosong. Setara dengan (= 0 (len col)).

=> (kosong? [])
Benar

=> (kosong? "")
Benar

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

setiap?
Baru di versi 0.10.0.

Pemakaian: (setiap? mendahului col)

Pengembalian Benar if (sebelumnya x) logis benar untuk setiap x in coll, Jika tidak Salah. Kembali Benar
if coll kosong.

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

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

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

=> (setiap? genap? [])
Benar

mengapung?
Pemakaian: (mengambang? x)

Pengembalian Benar if x adalah pelampung.

=> (mengambang? 3.2)
Benar

=> (mengambang? -2)
Salah

bahkan?
Pemakaian: (bahkan? x)

Pengembalian Benar if x adalah genap. meningkatkan KetikError if (Tidak (numerik? X)).

=> (genap? 2)
Benar

=> (genap? 13)
Salah

=> (genap? 0)
Benar

identitas
Pemakaian: (identitas x)

Mengembalikan argumen yang diberikan ke fungsi.

=> (identitas 4)
4

=> (daftar (identitas peta [1 2 3 4])))
[1 2 3 4]

inc
Pemakaian: (termasuk x)

Mengembalikan satu lebih dari x. Setara dengan (+ x 1). meningkatkan KetikError if (Tidak (numerik? X)).

=> (termasuk 3)
4

=> (termasuk 0)
1

=> (termasuk 12.3)
13.3

contoh?
Pemakaian: (contoh? kelas x)

Pengembalian 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

bilangan bulat?
Pemakaian: (bilangan bulat? x)

Pengembalian Benar if x adalah bilangan bulat. Untuk Python 2, ini juga int or panjang. Untuk Python3,
ini int.

=> (bilangan bulat? 3)
Benar

=> (bilangan bulat? -2.4)
Salah

menjalin
Baru di versi 0.10.1.

Pemakaian: (menjalin seq1 seq2 ...)

Mengembalikan iterable dari item pertama di setiap urutan, lalu yang kedua, dll.

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

=> (daftar (sisipkan (kisaran 1000000) "abc"))
[0, 'a', 1, 'b', 2, 'c']

menempatkan
Baru di versi 0.10.1.

Pemakaian: (menempatkan barang seq)

Mengembalikan iterable dari elemen urutan yang dipisahkan oleh item.

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

=> (daftar (interpose -1 (rentang 5))))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

bisa diubah?
Pemakaian: (bisa diubah? x)

Pengembalian Benar if x dapat diubah. Objek yang dapat diubah mengembalikan iterator baru ketika (itu x) is
ditelepon. Kontras dengan pengulangan?.

=> ;; bekerja untuk string
=> (dapat diubah? (str "abcde"))
Benar

=> ;; bekerja untuk daftar
=> (dapat diubah? [1 2 3 4 5])
Benar

=> ;; bekerja untuk tupel
=> (bisa diubah? (, 1 2 3))
Benar

=> ;; bekerja untuk dikte
=> (dapat diubah? {:a 1 :b 2 :c 3})
Benar

=> ;; bekerja untuk iterator/generator
=> (dapat diubah? (ulangi 3))
Benar

pengulangan?
Pemakaian: (pengulangan? x)

Pengembalian Benar if x adalah seorang iterator. Iterator adalah objek yang mengembalikan dirinya sendiri sebagai
iterator kapan (itu x) disebut. Kontras dengan bisa diubah?.

=> ;; tidak berfungsi untuk daftar
=> (pengulangan? [1 2 3 4 5])
Salah

=> ;; tapi kita bisa mendapatkan iter dari daftar
=> (iterator? (iter [1 2 3 4 5]))
Benar

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

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

Daftar*
Pemakaian: (Daftar* kepala &istirahat ekor)

Menghasilkan rantai sel kontra bersarang (daftar putus-putus) yang berisi argumen. jika
daftar argumen hanya memiliki satu elemen, kembalikan.

=> (daftar* 1 2 3 4)
(1 2 3)

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

=> (daftar* 1)
1

=> (kontra? (daftar* 1 2 3 4))
Benar

perluasan makro
Baru di versi 0.10.0.

Pemakaian: (perluasan makro untuk m)

Mengembalikan ekspansi makro penuh dari bentuk.

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

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

makroexpand-1
Baru di versi 0.10.0.

Pemakaian: (perluasan makro-1 untuk m)

Mengembalikan ekspansi makro satu langkah dari bentuk.

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

bergabung dengan
Baru di versi 0.10.1.

Pemakaian: (bergabung dengan f &istirahat peta)

Mengembalikan peta yang terdiri dari sisa peta yang digabungkan terlebih dahulu. Jika kunci terjadi di
lebih dari satu peta, pemetaan dari peta terakhir (kiri-ke-kanan) akan digabungkan dengan
pemetaan dalam hasil dengan memanggil (f val-in-hasil val-in-yang terakhir).

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

tidak?
Pemakaian: (negatif? x)

Pengembalian Benar if x kurang dari nol. meningkatkan KetikError if (Tidak (numerik? X)).

=> (neg? -2)
Benar

=> (neg? 3)
Salah

=> (neg? 0)
Salah

nol?
Pemakaian: (nol? x)

Pengembalian Benar if x is nol / None.

=> (nihil? nihil)
Benar

=> (nihil? Tidak ada)
Benar

=> (nihil? 0)
Salah

=> (setf x nihil)
=> (nihil? x)
Benar

=> ;; list.append selalu mengembalikan Tidak Ada
=> (nihil? (.tambahkan [1 2 3] 4))
Benar

tidak ada?
Pemakaian: (tidak ada? x)

Pengembalian Benar if x is None.

=> (tidak ada? Tidak ada)
Benar

=> (tidak ada? 0)
Salah

=> (setf x Tidak Ada)
=> (tidak ada? x)
Benar

=> ;; list.append selalu mengembalikan Tidak Ada
=> (tidak ada? (.tambahkan [1 2 3] 4))
Benar

n
Pemakaian: (ke-n coll n &opsional [bawaan nol])

Mengembalikan n-item dalam koleksi, dihitung dari 0. Mengembalikan nilai default, nol, Jika
di luar batas (kecuali ditentukan lain). meningkatkan NilaiError if n negatif.

=> (ke-n [1 2 4 7] 1)
2

=> (ke-n [1 2 4 7] 3)
7

=> (nihil? (ke-n [1 2 4 7] 5))
Benar

=> (ke-n [1 2 4 7] 5 "default")
'bawaan'

=> (ke-n (ambil 3 (jatuhkan 2 [1 2 3 4 5 6]))) 2))
5

=> (ke-n [1 2 4 7] -1)
Traceback (panggilan terakhir terakhir):
...
ValueError: Indeks untuk islice() harus None atau integer: 0 <= x <= sys.maxsize.

numerik?
Pemakaian: (numerik? x)

Pengembalian Benar if x adalah numerik, seperti yang didefinisikan dalam Python's angka.Nomor kelas.

=> (angka? -2)
Benar

=> (angka? 3.2)
Benar

=> (numerik? "foo")
Salah

aneh?
Pemakaian: (aneh? x)

Pengembalian Benar if x aneh. meningkatkan KetikError if (Tidak (numerik? X)).

=> (ganjil? 13)
Benar

=> (ganjil? 2)
Salah

=> (ganjil? 0)
Salah

pos?
Pemakaian: (pos? x)

Pengembalian Benar if x lebih besar dari nol. meningkatkan KetikError if (Tidak (numerik? X)).

=> (pos? 3)
Benar

=> (pos? -2)
Salah

=> (pos? 0)
Salah

kedua
Pemakaian: (kedua col)

Mengembalikan anggota kedua dari coll. Setara dengan (Dapatkan coll 1).

=> (kedua [0 1 2])
1

beberapa
Baru di versi 0.10.0.

Pemakaian: (beberapa mendahului col)

Mengembalikan nilai logika-benar pertama dari (sebelumnya x) untuk setiap x in coll, Jika tidak nol.
Pengembalian nol if coll kosong.

=> (bahkan beberapa? [2 4 6])
Benar

=> (nihil? (bahkan ada yang? [1 3 5]))
Benar

=> (nihil? (beberapa identitas [0 "" []]))
Benar

=> (beberapa identitas [0 "tidak kosong-string" []])
'tidak-kosong-string'

=> (nihil? (beberapa bahkan? []))
Benar

rangkaian?
Pemakaian: (rangkaian? x)

Pengembalian Benar if x adalah string.

=> (string? "foo")
Benar

=> (tali? -2)
Salah

simbol?
Pemakaian: (simbol? x)

Pengembalian Benar if x adalah simbol.

=> (simbol? 'foo)
Benar

=> (simbol? '[abc])
Salah

nol?
Pemakaian: (nol? x)

Pengembalian Benar if x adalah nol.

=> (nol? 3)
Salah

=> (nol? -2)
Salah

=> (nol? 0)
Benar

Urutan Fungsi
Fungsi urutan dapat membuat atau beroperasi pada urutan yang berpotensi tak terbatas tanpa
membutuhkan urutan direalisasikan sepenuhnya dalam daftar atau wadah serupa. Mereka melakukan ini dengan
mengembalikan iterator Python.

Kita dapat menggunakan generator bilangan Fibonacci tak terhingga kanonik sebagai contoh cara menggunakan
beberapa fungsi tersebut.

(jelas fib []
(atur 0)
(setv b 1)
(sementara benar
(hasil a)
(setv (, ab) (, b (+ ab))))))

Perhatikan (ketika benar ...) lingkaran. Jika kita menjalankan ini di REPL,

=> (fib)


Memanggil fungsi hanya mengembalikan iterator, tetapi tidak berfungsi sampai kita mengkonsumsinya.
Mencoba sesuatu seperti ini tidak disarankan karena infinite loop akan berjalan sampai
mengkonsumsi semua RAM yang tersedia, atau dalam hal ini sampai saya membunuhnya.

=> (daftar (fib))
[1] 91474 terbunuh hy

Untuk mendapatkan 10 angka Fibonacci pertama, gunakan mengambil. Catat itu mengambil juga mengembalikan generator,
jadi saya membuat daftar dari itu.

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

Untuk mendapatkan angka Fibonacci pada indeks 9, (mulai dari 0):

=> (ke-n (fib) 9)
34

siklus
Pemakaian: (siklus col)

Mengembalikan iterator tak terbatas dari anggota col.

=> (daftar (ambil 7 (siklus [1 2 3]))))
[1, 2, 3, 1, 2, 3, 1]

=> (daftar (ambil 2 (siklus [1 2 3]))))
[1, 2]

berbeda
Pemakaian: (berbeda col)

Mengembalikan iterator yang hanya berisi anggota unik di coll.

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

=> (daftar (berbeda []))
[]

=> (daftar (berbeda (iter [ 1 2 3 4 3 5 2 ])))
[1, 2, 3, 4, 5]

menjatuhkan
Pemakaian: (penurunan n col)

Mengembalikan iterator, melewatkan yang pertama n anggota coll. meningkatkan NilaiError if n is
negatif.

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

=> (daftar (lepaskan 4 [1 2 3 4 5]))
[5]

=> (daftar (lepaskan 0 [1 2 3 4 5]))
[1, 2, 3, 4, 5]

=> (daftar (lepaskan 6 [1 2 3 4 5]))
[]

drop-terakhir
Pemakaian: (jatuh-terakhir n col)

Mengembalikan iterator dari semua kecuali yang terakhir n item dalam coll. meningkatkan NilaiError if n is
negatif.

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

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

=> (daftar (jatuhkan-terakhir 100 (rentang 100)))
[]

=> (impor itertools)
=> (daftar (ambil 5 (drop-last 100 (itertools.count 10)))))
[10, 11, 12, 13, 14]

drop-sementara
Pemakaian: (drop-sementara mendahului col)

Mengembalikan iterator, melewatkan anggota coll sampai mendahului is Salah.

=> (daftar (turun sementara genap? [2 4 7 8 9]))
[7, 8, 9]

=> (daftar (nomor drop-sementara? [1 2 3 Tidak ada "a"]))))
[Tidak ada, u'a']

=> (daftar (posting sementara? [2 4 7 8 9]))
[]

menyaring
Pemakaian: (Saring mendahului col)

Mengembalikan iterator untuk semua item di coll yang lulus predikat mendahului.

Lihat juga menghapus.

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

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

meratakan
Baru di versi 0.9.12.

Pemakaian: (meratakan col)

Mengembalikan satu daftar semua item di coll, dengan meratakan semua daftar yang ada 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']

pengulangan
Pemakaian: (pengulangan fn x)

Mengembalikan iterator dari x, fn(x), fn(fn(x)), Dll

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

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

Baca baca
Pemakaian: (Baca baca &opsional [dari-file eof])

Membaca ekspresi Hy berikutnya dari dari file (default ke sys.stdin), dan dapat mengambil
byte tunggal sebagai EOF (default ke string kosong). meningkatkan EOFEkesalahan if dari file berakhir sebelum
ekspresi lengkap dapat diuraikan.

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

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

=> ; dengan asumsi "example.hy" berisi:
=> ; (cetak "halo")
=> ; (cetak "teman!")
=> (dengan [[f (buka "example.hy")]]
... (mencoba
... (sementara benar
... (biarkan [[exp (baca f)]]
... (melakukan
... (cetak "OHY" exp)
... (eval exp))))
... (tangkap [e EOFError]
... (cetak "EOF!"))))
OHY ('cetak' 'halo')
halo
OHY ('cetak' 'teman!')
teman!
EOF!

menghapus
Pemakaian: (menghapus mendahului col)

Mengembalikan iterator dari coll dengan elemen yang melewati predikat, mendahului, DIHAPUS.

Lihat juga menyaring.

=> (daftar (hapus ganjil? [1 2 3 4 5 6 7]))
[2, 4, 6]

=> (daftar (hapus pos? [1 2 3 4 5 6 7]))
[]

=> (daftar (hapus neg? [1 2 3 4 5 6 7]))
[1, 2, 3, 4, 5, 6, 7]

ulangi
Pemakaian: (ulang x)

Mengembalikan iterator (tak terbatas) dari x.

=> (daftar (ambil 6 (ulangi "s"))))
[u's', u's', u's', u's', u's', u's']

berkali-kali
Pemakaian: (berkali-kali fn)

Mengembalikan iterator dengan memanggil fn berkali-kali.

=> (impor [acak [random]])

=> (daftar (ambil 5 (berulang-ulang (fn [] (randint 0 10)))))
[6, 2, 0, 6, 7]

mengambil
Pemakaian: (mengambil n col)

Mengembalikan iterator yang berisi yang pertama n anggota coll. meningkatkan NilaiError if n is
negatif.

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

=> (daftar (ambil 4 (ulangi "s"))))
[u's', u's', u's', u's']

=> (daftar (ambil 0 (ulangi "s"))))
[]

ambil-nth
Pemakaian: (ambil-nth n col)

Mengembalikan iterator yang berisi setiap n-anggota dari coll.

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

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

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

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

mengambil-sementara
Pemakaian: (mengambil-sementara mendahului col)

Mengembalikan iterator dari coll selama mendahului Pengembalian Benar.

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

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

=> (daftar (ambil-sementara neg? [ 1 2 3 -4 5]))
[]

zipwith
Baru di versi 0.9.13.

Pemakaian: (zip dengan fn coll ...)

Setara dengan zip, tetapi menggunakan fungsi multi-argumen alih-alih membuat Tuple. Jika
zipwith disebut dengan koleksi N, maka fn harus menerima N argumen.

=> (operator impor)
=> (daftar (zipwith operator.add [1 2 3] [4 5 6]))
[5, 7, 9]

Pembaca Macro
Makro pembaca memberi Lisp kekuatan untuk memodifikasi dan mengubah sintaks dengan cepat. Anda tidak ingin
notasi Polandia? Makro pembaca dapat dengan mudah melakukan hal itu. Ingin cara Clojure untuk memiliki
ekspresi reguler? Makro pembaca juga dapat melakukan ini dengan mudah.

Sintaksis
=> (defreader ^ [expr] (cetak expr))
=> #^(1 2 3 4)
(1)
=> #^"Halo"
"Halo"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

Hy tidak memiliki literal untuk tupel. Katakanlah Anda tidak suka (, ...) dan menginginkan sesuatu yang lain. Ini
adalah makro pembaca masalah yang dapat diselesaikan dengan cara yang rapi.

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

Anda bahkan dapat melakukannya seperti Clojure dan memiliki literal untuk ekspresi reguler!

=> (impor ulang)
=> (defreader r [expr] `(kompilasi ulang ~expr))
=> #r".*"
<_sre.SRE_Pattern objek di 0xcv7713ph15#>

Organisasi
defreader mengambil satu karakter sebagai nama simbol untuk makro pembaca; lebih lama
akan mengembalikan kesalahan. Implementasi-bijaksana, defreader mengembang menjadi lambda yang ditutupi dengan
penghias. Dekorator ini menyimpan lambda dalam kamus dengan nama modulnya dan
simbol.

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

# berkembang menjadi (pengiriman_pembaca_makro ...) di mana simbol dan ekspresi diteruskan ke
fungsi yang benar.

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

PERINGATAN:
Karena keterbatasan dalam lexer dan parser Hy, makro pembaca tidak dapat didefinisikan ulang
sintaks seperti ()[]{}. Ini kemungkinan besar akan ditangani di masa depan.

Intern Hy Dokumentasi
CATATAN:
Bit ini sebagian besar berguna untuk orang-orang yang meretas Hy itu sendiri, tetapi juga dapat digunakan untuk
mereka yang mempelajari lebih dalam pemrograman makro.

Hy Model
Pengantar untuk Hy Model
Model Hy adalah lapisan yang sangat tipis di atas objek Python biasa, mewakili sumber Hy
kode sebagai data. Model hanya menambahkan informasi posisi sumber, dan beberapa metode untuk
mendukung manipulasi bersih kode sumber Hy, misalnya dalam makro. Untuk mencapai itu
tujuan, model Hy adalah campuran dari kelas Python dasar dan Objek Hy.

Objek Hy
hy.models.HyObject adalah kelas dasar dari model Hy. Ini hanya menerapkan satu metode, menggantikan,
yang menggantikan posisi sumber objek saat ini dengan yang diteruskan sebagai argumen.
Ini memungkinkan kita untuk melacak posisi asli ekspresi yang dimodifikasi oleh
makro, baik itu di kompiler atau di makro hy murni.

Objek Hy tidak dimaksudkan untuk digunakan secara langsung untuk membuat instance model Hy, tetapi hanya sebagai mixin
untuk kelas lain.

Senyawa Model
Daftar dalam kurung dan tanda kurung diuraikan sebagai model gabungan oleh parser Hy.

Daftar Hy
hy.models.list.HyList adalah kelas dasar dari model Hy yang "dapat diubah". Penggunaan dasarnya adalah untuk
mewakili tanda kurung [] daftar, yang, ketika digunakan sebagai ekspresi tingkat atas, diterjemahkan menjadi
Python daftar literal dalam fase kompilasi.

Menambahkan HyList ke objek iterable lain menggunakan kembali kelas objek sisi kiri,
perilaku yang berguna saat Anda ingin menggabungkan objek Hy dalam makro, misalnya.

Ekspresi Hy
hy.models.ekspresi.HyExpression mewarisi Daftar Hy untuk tanda kurung () ekspresi. Itu
hasil kompilasi dari ekspresi tersebut tergantung pada elemen pertama dari daftar: the
compiler mengirimkan ekspresi antara compiler bentuk khusus, makro yang ditentukan pengguna, dan
panggilan fungsi Python biasa.

HyDict
hy.models.dict.HyDict mewarisi Daftar Hy untuk kurung kurawal {} ekspresi, yang mengkompilasi
ke kamus Python literal.

Keputusan menggunakan daftar alih-alih dict sebagai kelas dasar untuk HyDict memungkinkan lebih mudah
manipulasi dicts di makro, dengan manfaat tambahan memungkinkan ekspresi majemuk
sebagai kunci dict (seperti, misalnya, the Ekspresi Hy Kelas Python tidak dapat di-hash).

Atom Model
Di aliran input, string yang dikutip ganda, dengan menghormati notasi Python untuk string,
diuraikan sebagai token tunggal, yang langsung diuraikan sebagai HyString.

String karakter yang tidak terputus, tidak termasuk spasi, tanda kurung, tanda kutip, tanda kutip ganda
dan komentar, diuraikan sebagai pengenal.

Pengidentifikasi diselesaikan ke model atom selama fase penguraian dalam urutan berikut:

· HyInteger

· HyFloat

· HiKompleks (jika atom tidak telanjang j)

· Kata Kunci Hy (jika atom dimulai dengan :)

· HySimbol

HyString
hy.models.string.HyString adalah kelas dasar model Hy setara string. Juga
mewakili literal string yang dikutip ganda, "", yang dikompilasi ke string unicode
literal dalam Python. HyString mewarisi objek unicode di Python 2, dan objek string di
Python 3 (dan karenanya tidak bergantung pada penyandian).

HyString model berbasis tidak berubah.

String literal Hy dapat menjangkau beberapa baris, dan dianggap oleh parser sebagai satu baris
unit, menghormati pelarian Python untuk string unicode.

Numeric Model
hy.models.integer.HyInteger mewakili literal integer (menggunakan panjang ketik di Python 2,
dan int pada Python 3).

hy.models.float.HyFloat mewakili literal floating-point.

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

Model numerik diuraikan menggunakan rutin Python yang sesuai, dan python numerik yang valid
literal akan diubah menjadi rekan Hy mereka.

HySimbol
hy.models.symbol.HySymbol adalah model yang digunakan untuk merepresentasikan simbol dalam bahasa Hy. Dia
mewarisi HyString.

HySimbol objek hancur dalam fase parsing, untuk membantu interoperabilitas Python:

· Simbol dikelilingi oleh tanda bintang (*) diubah menjadi huruf besar;

· Tanda hubung (-) diubah menjadi garis bawah (_);

· Satu tanda tanya tambahan (?) berubah menjadi terkemuka adalah_.

Peringatan: karena mangling dilakukan selama fase penguraian, dimungkinkan untuk
menghasilkan HySymbols secara terprogram yang tidak dapat dibuat dengan kode sumber Hy. Misalnya
mekanisme yang digunakan oleh gensym untuk menghasilkan simbol "tidak diinternir".

Kata Kunci Hy
hy.models.keyword.HyKeyword mewakili kata kunci dalam Hy. Kata kunci adalah simbol yang dimulai dengan
a :. Kelas mewarisi HyString.

Untuk membedakan Kata Kunci Hy dari Simbol Hy, tanpa kemungkinan (tidak disengaja)
bentrokan, karakter unicode penggunaan pribadi "\uFDD0" diawali dengan kata kunci literal
sebelum penyimpanan.

Kekurangan Sel
hy.models.cons.HyCons adalah representasi dari Python-friendly kontra sel. Sel kontra adalah
sangat berguna untuk meniru fitur varian LISP "biasa" seperti Skema atau Umum
Pelat.

Sel kontra adalah objek 2-item, berisi a mobil (kepala) dan a cdr (ekor). Dalam beberapa Lisp
varian, sel kontra adalah blok bangunan fundamental, dan ekspresi S sebenarnya
direpresentasikan sebagai daftar sel kontra yang ditautkan. Ini tidak terjadi di Hy, seperti biasanya
ekspresi terbuat dari daftar Python yang dibungkus dengan Ekspresi Hy. Namun, HyCons
meniru perilaku varian Lisp "biasa" sebagai berikut:

· (kontra sesuatu nol) is (HyEkspresi [sesuatu])

· (kontra sesuatu beberapa daftar) is ((Tipe beberapa daftar) (+ [sesuatu] beberapa daftar)) (jika
beberapa daftar mewarisi dari daftar).

· (Dapatkan (kontra a b) 0) is a

· (mengiris (kontra a b) 1) is b

Hy mendukung sintaks daftar putus-putus, di mana '(sebuah . b) cara (kontra 'a 'B) dan '(sebuah b . c) cara
(kontra 'a (kontra 'b 'C)). Jika kompiler menemukan sel kontra di tingkat atas, itu menimbulkan
kesalahan kompilasi.

HyCons membungkus argumen yang diteruskan (mobil dan cdr) dalam tipe Hy, untuk memudahkan manipulasi
kontra sel dalam konteks makro.

Hy Intern Teori
Ringkasan
Internal Hy bekerja dengan bertindak sebagai front-end untuk bytecode Python, sehingga Hy itu sendiri
mengkompilasi ke Python Bytecode, memungkinkan runtime Python yang tidak dimodifikasi untuk menjalankan kode Hy,
bahkan tanpa menyadarinya.

Cara kami melakukannya adalah dengan menerjemahkan Hy ke dalam struktur data AST Python internal, dan
membangun AST itu menjadi bytecode Python menggunakan modul dari standar Python
perpustakaan, sehingga kita tidak perlu menduplikasi semua pekerjaan internal Python untuk setiap
rilis Python tunggal.

Hy bekerja dalam empat tahap. Bagian berikut akan membahas setiap langkah Hy dari sumber ke
waktu berjalan.

Tangga 1 dan 2: Tokenizing dan Penguraian
Tahap pertama mengkompilasi Hy adalah lex source menjadi token yang bisa kita tangani. Kami
gunakan proyek bernama rply, yang merupakan parser yang sangat bagus (dan cepat), ditulis dalam subset
dari Python disebut rpython.

Kode lexing semuanya didefinisikan dalam hy.lex.lexer. Kode ini kebanyakan hanya mendefinisikan Hy
tata bahasa, dan semua bagian yang sulit ditangani oleh rply -- kami hanya mendefinisikan
"panggilan balik" untuk rply in hy.lex.parser, yang mengambil token yang dihasilkan, dan mengembalikan
Hai model.

Anda dapat menganggap model Hy sebagai "AST" untuk Hy, itulah yang dioperasikan oleh Macro
(secara langsung), dan itulah yang digunakan kompiler ketika mengkompilasi Hy ke bawah.

SEE JUGA:
Bagian Hy Model untuk informasi lebih lanjut tentang model Hy dan apa artinya.

Langkah 3: Hy Kompilasi untuk Ular sanca AST
Di sinilah sebagian besar keajaiban di Hy terjadi. Di sinilah kami mengambil Hy AST (model),
dan kompilasi ke dalam Python AST. Beberapa hal yang funky terjadi di sini untuk bekerja melewati beberapa
masalah di AST, dan bekerja di kompiler adalah beberapa pekerjaan terpenting yang kami lakukan
memiliki.

Kompilernya agak rumit, jadi jangan merasa buruk jika Anda tidak melakukannya pada kesempatan pertama,
mungkin perlu sedikit waktu untuk memperbaikinya.

Titik masuk utama ke Kompilator adalah HyASTCompiler.kompilasi. Metode ini dipanggil, dan
satu-satunya metode "publik" nyata di kelas (artinya, kami tidak benar-benar menjanjikan
API di luar metode itu).

Faktanya, bahkan secara internal, kami tidak berulang secara langsung hampir tidak pernah, kami hampir selalu memaksa
pohon Hy melalui menyusun, dan akan sering melakukan ini dengan sub-elemen dari sebuah ekspresi
yang kita miliki. Terserah operator berbasis Tipe untuk mengirimkan sub-elemen dengan benar.

Semua metode yang membentuk kompilasi sebelumnya ditandai dengan @membangun() penghias. Kamu bisa
baik melewati kelas model Hy yang dikompilasi, atau Anda dapat menggunakan string untuk
ekspresi. Saya akan membereskan ini sebentar lagi.

Pertama Tahap Jenis-Pengiriman
Mari kita mulai di menyusun metode. Hal pertama yang kami lakukan adalah memeriksa Jenis barangnya
kami sedang membangun. Kami mencari untuk melihat apakah kami memiliki metode yang dapat membangun Tipe() bahwa kita
miliki, dan kirim ke metode yang dapat menanganinya. Jika kita tidak memiliki metode yang bisa
membangun tipe itu, kami meningkatkan internal Pengecualian.

Misalnya, jika kita memiliki HyString, kami memiliki pemetaan hampir 1-ke-1 dari Hy AST ke Python
AST. Itu kompilasi_string metode mengambil HyString, dan mengembalikan ast.Str() itu
diisi dengan nomor baris dan konten yang benar.

Makro-Perluas
Jika kita mendapatkan Ekspresi Hy, kami akan mencoba untuk melihat apakah ini adalah Makro yang dikenal, dan mendorong untuk memiliki
itu diperluas dengan memanggil hy.macros.macroexpand, lalu dorong hasilnya kembali ke
HyASTCompiler.kompilasi.

Kedua Tahap Ekspresi-Pengiriman
Satu-satunya kasus khusus adalah Ekspresi Hy, karena kita perlu membuat AST yang berbeda tergantung
pada formulir khusus yang bersangkutan. Misalnya, ketika kita menekan (jika benar benar Salah), Kami
perlu menghasilkan ast.Jika, dan kompilasi sub-node dengan benar. Di sinilah @membangun()
dengan String sebagai argumen masuk.

Untuk kompilasi_ekspresi (yang didefinisikan dengan @builds(HyEkspresi)) akan mengirimkan
berdasarkan string argumen pertama. Jika, untuk beberapa alasan, argumen pertama tidak
string, itu akan menangani kasus itu dengan baik juga (kemungkinan besar dengan menaikkan Pengecualian).

Jika String tidak diketahui oleh Hy, maka defaultnya akan membuat ast.Panggilan, yang akan mencoba
lakukan panggilan runtime (dengan Python, sesuatu seperti foo()).

Isu Memukul dengan Ular sanca AST
Python AST sangat bagus; itulah yang memungkinkan kami untuk menulis proyek yang begitu kuat di atas
Python tanpa harus melawan Python terlalu keras. Seperti apa pun, kami memiliki bagian yang adil dari
masalah, dan berikut adalah daftar singkat masalah umum yang mungkin Anda alami.

Ular sanca membedakan antara Laporan dan Ekspresi.

Ini mungkin tidak terdengar seperti masalah besar -- pada kenyataannya, bagi sebagian besar programmer Python, ini akan
segera menjadi momen "Yah, ya".

Dengan Python, melakukan sesuatu seperti:

mencetak untuk x in jarak(10): lulus, Karena mencetak mencetak ekspresi, dan untuk bukan
ekspresi, itu adalah pernyataan aliran kontrol. Hal-hal seperti 1 + 1 adalah Ekspresi, apa adanya lambda
x: 1 + x, tetapi fitur bahasa lainnya, seperti if, untuk, atau sementara adalah pernyataan.

Karena mereka tidak memiliki "nilai" untuk Python, ini membuat bekerja di Hy sulit, karena melakukan sesuatu
'like' (mencetak (jika benar benar Salah)) tidak hanya umum, itu diharapkan.

Sebagai hasilnya, kami melakukan auto-mangle menggunakan a Hasil objek, di mana kami menawarkan apa pun ast.stmt
yang perlu dijalankan, dan satu ast.expr yang dapat digunakan untuk mendapatkan nilai apa pun
baru saja dijalankan. Hy melakukan ini dengan memaksa penugasan ke berbagai hal saat berlari.

Sebagai contoh, Hy:

(cetak (jika benar benar salah))

Akan berubah menjadi:

jika benar:
_mangled_name_here = Benar
lain:
_mangled_name_here = Salah

cetak _mangled_name_here

Oke, itu sedikit bohong, karena kami benar-benar mengubah pernyataan itu menjadi:

cetak Benar jika Benar yang lain Salah

Dengan memaksa sesuatu menjadi ast.expr jika kita bisa, tetapi ide umumnya berlaku.

Langkah 4: Ular sanca Kode Bytecode Keluaran dan Runtime
Setelah kita memiliki pohon AST Python yang lengkap, kita dapat mencoba dan mengkompilasinya ke Python
bytecode dengan mendorongnya evaluasi. Mulai sekarang, kita tidak lagi memegang kendali, dan
Python mengurus semuanya. Inilah sebabnya mengapa hal-hal seperti traceback Python, pdb dan
aplikasi django berfungsi.

Hy Macro
Menggunakan gensym untuk Lebih aman Macro
Saat menulis makro, seseorang harus berhati-hati untuk menghindari menangkap variabel eksternal atau menggunakan
nama variabel yang mungkin bertentangan dengan kode pengguna.

Kami akan menggunakan contoh makro bagus (Lihat
http://letoverlambda.com/index.cl/guest/chap3.html#detik_5 untuk penjelasan yang lebih lengkap.)
bagus adalah contoh, sesuatu seperti angka if, di mana berdasarkan ekspresi, salah satu dari
3 bentuk disebut tergantung pada apakah ekspresinya positif, nol atau negatif.

Pass pertama mungkin seperti:

(defmacro nif [expr pos-form bentuk-nol bentuk-negatif]
`(biarkan [[nama tidak jelas ~expr]]
(cond [(pos? nama tidak jelas) ~pos-form]
[(nol? nama tidak jelas) ~bentuk nol]
[(neg? nama tidak jelas) ~neg-form])))

dimana nama-ketidakjelasan adalah upaya untuk memilih beberapa nama variabel agar tidak bertentangan dengan yang lain
kode. Tapi tentu saja, meski bermaksud baik, ini bukan jaminan.

Metode gensym dirancang untuk menghasilkan simbol baru yang unik untuk kesempatan seperti itu.
Versi yang jauh lebih baik dari bagus akan menjadi:

(defmacro nif [expr pos-form bentuk-nol bentuk-negatif]
(biarkan [[g (gensym)]]
`(biarkan [[~g ~expr]]
(lanjutan [(pos? ~g) ~bentuk-pos]
[(nol? ~g) ~bentuk nol]
[(neg? ~g) ~neg-bentuk]))))

Ini adalah kasus yang mudah, karena hanya ada satu simbol. Tetapi jika ada kebutuhan untuk beberapa
gensym's ada makro kedua dengan-gensyms yang pada dasarnya berkembang menjadi serangkaian membiarkan
pernyataan:

(dengan-gensyms [abc]
...)

berkembang menjadi:

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

jadi kami menulis ulang bagus akan terlihat seperti:

(defmacro nif [expr pos-form bentuk-nol bentuk-negatif]
(dengan-gensyms [g]
`(biarkan [[~g ~expr]]
(lanjutan [(pos? ~g) ~bentuk-pos]
[(nol? ~g) ~bentuk nol]
[(neg? ~g) ~neg-bentuk]))))

Akhirnya, meskipun kita dapat membuat makro baru yang melakukan semua ini untuk kita. defmakro/g! akan mengambil
semua simbol yang dimulai dengan g! dan secara otomatis memanggil gensym dengan sisa
simbol. Jadi g!a akan menjadi (gensim "A").

Versi terakhir kami dari bagus, dibangun dengan defmakro/g! menjadi:

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

Memeriksa Makro kasus dan pemeliharaan Pengecualian
Hy Penyusun Built-In

PENYUMBANG MODUL INDEKS

Isi:

Anaforis Macro
Baru di versi 0.9.12.

Modul makro anaforis membuat pemrograman fungsional di Hy sangat ringkas dan mudah
baca.
Makro anaforis adalah jenis makro pemrograman yang sengaja menangkap beberapa bentuk
dipasok ke makro yang dapat dirujuk oleh anaphor (ekspresi yang merujuk
ke yang lainnya). — Wikipedia (http://en.wikipedia.org/wiki/Anaphoric_macro)

Macro
ap-jika
Pemakaian: (ap-jika (foo) (mencetak dia))

Mengevaluasi bentuk pertama untuk kebenaran, dan mengikatnya ke it baik yang benar maupun yang salah
ranting.

buah persik
Pemakaian: (buah persik [1 2 3 4 5] (mencetak dia))

Evaluasi formulir untuk setiap elemen dalam daftar untuk efek samping.

ap-setiap-sementara
Pemakaian: (ap-setiap-sementara daftar mendahului tubuh)

Evaluasi formulir untuk setiap elemen tempat formulir predikat kembali Benar.

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

peta-ap
Pemakaian: (peta-ap bentuk Daftar)

Bentuk peta anaforis berfungsi seperti peta biasa kecuali itu alih-alih fungsi
objek itu mengambil bentuk Hy. Nama khusus it terikat ke objek saat ini dari
daftar dalam iterasi.

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

ap-peta-kapan
Pemakaian: (ap-peta-kapan predfn reputasi Daftar)

Evaluasi pemetaan atas daftar menggunakan fungsi predikat untuk menentukan kapan harus menerapkan
bentuk.

=> (daftar (ap-map-kapan ganjil? (* it 2) [1 2 3 4]))
[2, 2, 6, 4]

=> (daftar (ap-peta-kapan genap? (* itu 2) [1 2 3 4]))
[1, 4, 3, 8]

filter-ap
Pemakaian: (filter-ap bentuk Daftar)

Seperti peta-ap kami mengambil bentuk khusus alih-alih fungsi untuk memfilter elemen
Daftar. Nama khusus it terikat ke elemen saat ini dalam iterasi.

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

tolak ap
Pemakaian: (ap-tolak bentuk Daftar)

Fungsi ini melakukan kebalikan dari filter-ap, ia menolak elemen yang melewati
predikat. Nama khusus it terikat ke elemen saat ini dalam iterasi.

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

waktu-waktu
penggunaan (waktu-waktu n tubuh)

Fungsi ini mengevaluasi tubuh n kali, dengan variabel khusus it terikat dari 0 untuk
1-n. Ini berguna untuk efek samping.

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

ap-pertama
penggunaan (ap-pertama predfn Daftar)

Fungsi ini mengembalikan elemen pertama yang melewati predikat atau None, Dengan
variabel khusus it terikat ke elemen saat ini dalam iterasi.

=>(ap-pertama (> itu 5) (kisaran 10))
6

terakhir
penggunaan (ap-terakhir predfn Daftar)

Fungsi ini mengembalikan elemen terakhir yang melewati predikat atau None, dengan yang spesial
variabel it terikat ke elemen saat ini dalam iterasi.

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

ap-mengurangi
penggunaan (pengurangan-ap bentuk daftar &opsional nilai awal)

Fungsi ini mengembalikan hasil penerapan formulir ke 2 elemen pertama di badan dan
menerapkan hasil dan elemen ke-3 dll. sampai daftar habis. Opsional dan
nilai awal dapat diberikan sehingga fungsi akan diterapkan ke nilai awal dan
elemen pertama sebagai gantinya. Ini memperlihatkan elemen yang diulang sebagai it dan saat ini
akumulasi nilai sebagai acc.

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

loop/berulang
Baru di versi 0.10.0.

Grafik lingkaran / terulang makro memberi programmer cara sederhana untuk menggunakan optimasi panggilan ekor (TCO)
dalam kode Hy mereka.
Panggilan ekor adalah panggilan subrutin yang terjadi di dalam prosedur lain sebagai finalnya
tindakan; itu dapat menghasilkan nilai pengembalian yang kemudian segera dikembalikan oleh panggilan
prosedur. Jika ada panggilan yang dilakukan subrutin, sehingga pada akhirnya mungkin mengarah
untuk subrutin yang sama ini dipanggil lagi di rantai panggilan, berada di posisi ekor,
subrutin seperti itu dikatakan sebagai tail-recursive, yang merupakan kasus khusus dari rekursi.
Panggilan ekor sangat penting karena dapat diimplementasikan tanpa menambahkan tumpukan baru
bingkai ke tumpukan panggilan. Sebagian besar kerangka prosedur saat ini tidak diperlukan
lebih, dan itu bisa diganti dengan bingkai panggilan ekor. Program kemudian dapat melompat
ke subrutin yang dipanggil. Memproduksi kode seperti itu alih-alih urutan panggilan standar adalah
disebut penghapusan panggilan ekor, atau pengoptimalan panggilan ekor. Penghapusan panggilan ekor memungkinkan
prosedur memanggil posisi ekor untuk diimplementasikan seefisien pernyataan goto,
sehingga memungkinkan pemrograman terstruktur yang efisien. — Wikipedia (-
http://en.wikipedia.org/wiki/Tail_call)

Macro
lingkaran
lingkaran menetapkan titik rekursi. Dengan lingkaran, terulang rebind variabel yang diatur dalam
titik rekursi dan mengirimkan eksekusi kode kembali ke titik rekursi tersebut. Jika terulang digunakan dalam
posisi non-ekor, pengecualian dilemparkan.

Pemakaian: (lingkaran bindings &istirahat tubuh)

Contoh:

(memerlukan hy.contrib.loop)

(defn faktorial [n]
(loop [[dalam] [ak 1]]
(jika (nol? i)
acc
(berulang (dec i) (* acc i)))))

(faktorial 1000)

defmulti
Baru di versi 0.10.0.

defmulti memungkinkan Anda arity-overload fungsi dengan jumlah args dan/atau kwargs yang diberikan.
Terinspirasi oleh pandangan Clojure defn.

=> (memerlukan hy.contrib.multi)
=> (kesenangan defmulti
... ([A A")
... ([ab] "ab")
... ([abc] "abc"))
=> (menyenangkan 1)
"A"
=> (menyenangkan 1 2)
"ab"
=> (menyenangkan 1 2 3)
"abc"

PERETASAN ON HY

Ikuti seminar kami senang!
Silakan retas Hy!

Silakan datang bergaul dengan kami di #hai on irc.freenode.net!

Silakan membicarakannya di Twitter dengan #hai tanda pagar!

Silakan blog tentang itu!

Tolong jangan mengecatnya di pagar tetangga Anda (tanpa bertanya baik-baik)!

Hack!
Melakukan hal ini:

1. Membuat maya lingkungan Hidup:

$virtualenv venv

dan aktifkan:

$ . venv/bin/aktifkan

atau penggunaan virtualenvwrapper untuk membuat dan mengelola lingkungan virtual Anda:

$ mkvirtualenv hy
$bekerja hy

2. Dapatkan kode sumber:

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

atau gunakan garpu Anda:

klon $ git [email dilindungi]: /hy.git

3. Instal untuk meretas:

$ cd hy/
$pip install -e .

4. Instal persyaratan pengembangan lainnya:

$ pip instal -r persyaratan-dev.txt

5. Lakukan hal-hal yang mengagumkan; membuat seseorang menjerit senang/jijik atas apa yang telah Anda lakukan.

Tes!
Tes terletak di tes /. Kita gunakan hidung.

Untuk menjalankan tes:

$uji hidung

Tes tulis---tesnya bagus!

Juga, bagus untuk menjalankan tes untuk semua platform yang didukung dan untuk PEP 8 compliant
kode. Anda dapat melakukannya dengan menjalankan tox:

$ racun

Dokumen!
Dokumentasi terletak di dokumen /. Kita gunakan Orang yg merahasiakan pendapatnya.

Untuk membuat dokumen dalam HTML:

$cd dokumen
$ buat html

Tulis dokumen---dokumen itu bagus! Bahkan dokter ini!

Berkontribusi
Kontribusi diterima & sangat dihargai, setiap sedikit membantu dalam membuat Hy lebih banyak
mengagumkan

Permintaan tarik sangat bagus! Kami mencintai mereka; di sini adalah panduan cepat:

· Fork repo dan buat cabang topik untuk fitur/perbaikan. Hindari membuat perubahan secara langsung
pada cabang induk.

· Semua fitur yang masuk harus disertai dengan tes.

· Sebelum Anda mengirimkan PR, jalankan tes dan periksa kode Anda terhadap gaya
memandu. Anda dapat melakukan kedua hal ini sekaligus:

$ buat

· Buat komit menjadi unit logis, sehingga lebih mudah dilacak & dinavigasi nanti. Sebelum
mengirimkan PR, coba masukkan komit ke dalam set perubahan yang mudah untuk kembali
nanti. Juga, pastikan Anda tidak meninggalkan spasi kosong di set perubahan; ini
menghindari pembuatan komit perbaikan spasi putih nanti.

· Sejauh pesan komit berjalan, cobalah untuk mematuhi yang berikut:

· Cobalah tetap berpegang pada batas 50 karakter untuk baris pertama pesan komit Git.

· Untuk detail/penjelasan lebih lanjut, ikuti ini dengan baris kosong dan lanjutkan
menggambarkan komit secara rinci.

· Terakhir, tambahkan diri Anda ke file AUTHORS (sebagai komit terpisah): Anda layak mendapatkannya :)

· Semua perubahan yang masuk harus disetujui oleh 2 anggota tim inti Hylang yang berbeda.
Tinjauan tambahan jelas diterima, tetapi kami membutuhkan minimal 2 persetujuan untuk semua
berubah.

· Jika anggota inti mengirimkan PR, harap temukan 2 anggota inti yang tidak menyertakan
pengirim PR. Idenya di sini adalah bahwa seseorang dapat bekerja dengan penulis PR, dan yang kedua mengakui
seluruh set perubahan.

· Untuk dokumentasi & perubahan sepele lainnya, sebaiknya gabungkan setelah satu ACK. Kita punya
cakupan rendah, jadi akan bagus untuk menjaga penghalang itu tetap rendah.

Core Tim
Tim pengembangan inti Hy terdiri dari pengembang berikut:

· Julian Danjou

· Morten Linderud

· J Kenneth King

· gergely Nagy

· Tuukka Turto

· Karen Rust

· Abhishek L

· Christopher Allan Webber

· Konrad hinsen

· Akan Kahn-Greene

· paul Tagliamonte

· Nicolas Dandrimont

· Bob Tolbert

· berker Peksag

· Clinton N. Dreisbach

· dia semajo

Gunakan hy online menggunakan layanan onworks.net