hy - Online w chmurze

PROGRAM:

IMIĘ

hy - hy Dokumentacja [image: Hy] [image]

Próbować Hy https://try-hy.appspot.com

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

Źródło https://github.com/hylang/hy

Lista hylang-dyskusja

IRC #hej na Freenodzie

Budować status
Travis CI.NIEZDECYDOWANY

Hy to wspaniały dialekt Lisp osadzony w Pythonie.

Ponieważ Hy przekształca swój kod Lisp w abstrakcyjne drzewo składni Pythona, tak
cały piękny świat Pythona na wyciągnięcie ręki, w formie Lisp!

Spis treści:

SZYBKI START

[image: Przytulanie Karen Rustard] [image]

(Dzięki Karen Rustad za Cuddles!)

JAK DO GET HY Niezależne FAST:

1. Stwórz Wirtualny Python Środowisko.

2. Aktywuj swoje wirtualne środowisko Python.

3. Zainstalować hy od PyPI w pypeć zainstalować hy.

4. Rozpocznij REPL za pomocą hy.

5. Wpisz rzeczy w REPL:

=> (wydrukuj „Hej!”)
Hy!
=> (defn salutationsnm [imię] (print (+ "Hej" imię "!")))
=> (pozdrowienianm „Twoje imię”)
Twoje imię!

itp

6. Gdy skończysz, naciśnij CTRL-D.

O MÓJ BOŻE! Jest to niesamowity! I chcieć do napisać a Hy program.

7. Otwórz elitarny edytor programowania i wpisz:

(drukuj „Miałem zamiar kodować w składni Pythona, ale dostałem Hy.”)

8. Zapisz jako niesamowite.hy.

9. I uruchom swój pierwszy program Hy:

super.hy

10.
Weź głęboki oddech, aby nie wywołać hiperwentylacji.

11.
Uśmiechaj się złośliwie i wymykaj się do swojego hydeaway'a i rób niewypowiedziane rzeczy.

SEMINARIUM

Witamy w samouczku Hy!

W skrócie Hy jest dialektem Lispa, ale takim, który konwertuje swoją strukturę na język Python...
dosłownie konwersja na abstrakcyjne drzewo składni Pythona! (Albo ująć to bardziej prymitywnie
terminami, Hy jest sepleniący w Pythonie!)

To całkiem fajne, ponieważ oznacza, że ​​Hy to kilka rzeczy:

· Lisp, który wydaje się bardzo Pythoniczny

· Dla Lispersa, świetny sposób na wykorzystanie szalonych mocy Lispa, ale w szerokim świecie Pythona
biblioteki (dlaczego tak, teraz możesz napisać aplikację Django w Lisp!)

· Dla Pythonistas, świetny sposób na rozpoczęcie odkrywania Lispa, w zaciszu Pythona!

· Dla każdego: przyjemny język, który ma wiele fajnych pomysłów!

Basic Intro do Seplenienie dla Pythoniści
OK, może nigdy wcześniej nie korzystałeś z Lispa, ale używałeś Pythona!

Program „witaj świecie” w Hy jest w rzeczywistości bardzo prosty. Spróbujmy:

(wydrukuj „witaj świecie”)

Widzieć? Łatwy! Jak można się domyślić, jest to ta sama wersja, co wersja Pythona:

wydrukuj „witaj świecie”

Aby dodać bardzo prostą matematykę, moglibyśmy zrobić:

(+ 1 3)

Który zwróciłby 4 i byłby odpowiednikiem:

1 + 3

Zauważysz, że pierwszą pozycją na liście jest wywoływana funkcja, a
reszta argumentów to argumenty przekazywane. W rzeczywistości w Hy (jak w większości
Lisps) możemy przekazać wiele argumentów do operatora plus:

(+ 1 3 55)

Co zwróci 59.

Być może słyszałeś już o Lisp, ale niewiele o nim wiesz. Lisp nie jest tak trudny jak ty
mógłby pomyśleć, a Hy dziedziczy po Pythonie, więc Hy to świetny sposób na rozpoczęcie nauki Lispa.
Najważniejszą rzeczą oczywistą w Lisp jest to, że jest dużo nawiasów. To może
na początku wydają się skomplikowane, ale nie jest to takie trudne. Spójrzmy na prostą matematykę
owinięte w nawiasy, które moglibyśmy wprowadzić do interpretera Hy:

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

To zwróci 38. Ale dlaczego? Cóż, moglibyśmy przyjrzeć się równoważnemu wyrażeniu w
pyton:

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

Gdybyś miał spróbować dowiedzieć się, jak powyższe ma działać w Pythonie, oczywiście zrobiłbyś to
oblicz wyniki, rozwiązując każdy nawias wewnętrzny. To ta sama podstawowa idea
Hy. Wypróbujmy najpierw to ćwiczenie w Pythonie:

wynik = ((1 + 3 + 88) / 2) - 8
# uproszczone do...
wynik = (92 / 2) - 8
# uproszczone do...
wynik = 46 - 8
# uproszczone do...
wynik = 38

Teraz spróbujmy tego samego w Hy:

(wynik setv (- (/ (+ 1 3 88) 2) 8))
; uproszczone do...
(wynik setv (- (/ 92 2) 8))
; uproszczone do...
(wynik setv (- 46 8))
; uproszczone do...
(wynik setv 38)

Jak zapewne się domyślacie, to ostatnie wyrażenie z ustaw oznacza przypisanie zmiennej
„wynik” do 38.

Widzieć? Nie za mocno!

To jest podstawowe założenie Lispa. Lisp oznacza „przetwarzanie list”; oznacza to, że
struktura programu to tak naprawdę listy list. (Jeśli znasz Pythona
listach, wyobraź sobie całą tę samą strukturę jak powyżej, ale zamiast tego z nawiasami kwadratowymi, dowolną
powyższą strukturę będziesz mógł zobaczyć zarówno jako program, jak i strukturę danych.) To jest
łatwiej zrozumieć dzięki większej liczbie przykładów, więc napiszmy prosty program w Pythonie, przetestuj go,
a następnie pokaż równoważny program Hy:

def prosta_rozmowa():
drukuj "Witam! Chciałbym Cię poznać. Opowiedz mi o sobie!"
name = raw_input("Jak masz na imię? ")
wiek = raw_input("Jaki jest Twój wiek? ")
print "Witam " + imię + "! Widzę, że masz " + wiek + " lat."

prosta_rozmowa()

Gdybyśmy uruchomili ten program, mógłby wyglądać następująco:

Cześć! Chciałbym cię poznać. Opowiedz mi o sobie!
Jak masz na imię? Gary'ego
Ile masz lat? 38
Witaj Gary! Widzę, że masz 38 lat.

Przyjrzyjmy się teraz równoważnemu programowi Hy:

(zdefiniuj prostą rozmowę []
(drukuj "Witam! Chciałbym Cię poznać. Opowiedz mi o sobie!")
(nazwa setv (wejście surowe „Jak masz na imię?”))
(setv age (surowe dane wejściowe „Jaki jest Twój wiek?”))
(drukuj (+ „Witam „imię”! Widzę, że jesteś „
wiek „lata.”)))

(prosta rozmowa)

Jeśli spojrzysz na powyższy program, o ile pamiętasz, że pierwszy element w każdym
lista programu to wywoływana funkcja (lub makro... do tego dojdziemy później).
a że reszta to argumenty, dość łatwo jest zrozumieć, co to wszystko oznacza.
(Jak zapewne się domyślacie, zdefiniuj jest metodą Hy definiowania metod.)

Mimo to wiele osób na początku uważa to za mylące ze względu na dużą liczbę nawiasów,
ale jest wiele rzeczy, które mogą to ułatwić: zadbaj o ładne wcięcia i
użyj edytora z dopasowywaniem nawiasów (pomoże ci to dowiedzieć się, co każdy
nawias łączy się z) i wszystko zacznie być wygodne.

Posiadanie struktury kodu zawierającej w rzeczywistości bardzo proste dane ma pewne zalety
struktura, na której oparty jest rdzeń Lisp. Po pierwsze, oznacza to, że Twoje programy są
łatwe do przeanalizowania i że cała rzeczywista struktura programu jest bardzo wyraźnie widoczna
Tobie. (Jest dodatkowy krok w hy, w którym widoczna struktura jest konwertowana na strukturę Pythona
własne reprezentacje... w „czystszych” Lispsach, takich jak Common Lisp lub Emacs Lisp, dane
struktura, którą widzisz w kodzie, a wykonywana struktura danych to znacznie więcej
dosłownie blisko.)

Inną konsekwencją tego są makra: jeśli struktura programu składa się z prostych danych
strukturę, co oznacza, że ​​możesz pisać kod, który potrafi pisać kod bardzo łatwo, to znaczy
wdrażanie zupełnie nowych funkcji językowych może być bardzo szybkie. Poprzednio Hy, to nie było
bardzo możliwe dla programistów Pythona... teraz i Ty możesz korzystać z niesamowitych makr
moc (uważaj tylko, aby nie kierować ich w stronę stóp)!

Hy is a O smaku Lisp Python
Hy konwertuje do własnego abstrakcyjnego drzewa składni Pythona, więc wkrótce zaczniesz znajdować to wszystko
znana moc Pythona jest na wyciągnięcie ręki.

Masz pełny dostęp do typów danych Pythona i standardowej biblioteki w Hy. Poeksperymentujmy
z tym w tłumaczu hy:

=> [1 2 3]
[1, 2, 3]
=> {"pies" "szczeka"
... "kot" "miau"}
...
{'pies': 'szczekać', 'kot': 'miau'}
=> (, 1 2 3)
(1, 2, 3)

Jeśli znasz inne Lispy, możesz być zainteresowany tym, że Hy obsługuje Common
Lispowa metoda cytowania:

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

Masz także dostęp do wszystkich ładnych metod typów wbudowanych:

=> (.strip "fooooo")
„fuuu”

Co to jest? Tak, to dokładnie to samo, co:

" fooooo ".strip()

Zgadza się ---Lisp z notacją kropkową! Jeśli mamy ten ciąg znaków przypisany jako zmienną, my
może również wykonać następujące czynności:

(ustaw ten ciąg znaków „fooooo”)
(ten-string.strip)

A co z warunkami warunkowymi?:

(jeśli (spróbuj-czegoś)
(wydrukuj „to jest, jeśli to prawda”)
(wydrukuj „to jest, jeśli fałszywe”)

Jak widać powyżej, pierwszym argumentem do if jest testem prawdziwości, drugi argument jest
treść, jeśli jest prawdziwa, a trzeci argument (opcjonalny!) jest fałszywy (tj. więcej).

Jeśli potrzebujesz bardziej złożonych warunków warunkowych, przekonasz się, że ich nie masz Elif
dostępne w Hy. Zamiast tego powinieneś użyć czegoś o nazwie dyr. W Pythonie możesz to zrobić
coś jak:

Somevar = 33
jeśli wartość > 50:
print "Ta zmienna jest za duża!"
elif Somevar < 10:
print "Ta zmienna jest za mała!"
jeszcze:
print "Ta zmienna jest po prostu słuszna!"

W Hy zrobiłbyś:

(warunek
[(> trochę 50)
(drukuj „Ta zmienna jest za duża!”)]
[(< trochę 10)
(drukuj „Ta zmienna jest za mała!”)]
[PRAWDA
(wydrukuj „Ta zmienna jest po prostu słuszna!”)])

To, co zauważysz, to to dyr wyłącza się pomiędzy wykonywaną instrukcją a
sprawdzane warunkowo pod kątem prawdy lub fałszu, a następnie fragment kodu do wykonania, jeśli się zmieni
okazało się prawdą. Zauważysz także, że więcej jest realizowany na końcu po prostu przez
Sprawdzanie dla prawdziwy -- To jest ponieważ prawdziwy zawsze będzie prawdą, więc jeśli zajdziemy tak daleko, to zrobimy
zawsze uruchamiaj ten!

Możesz zauważyć powyżej, jeśli masz kod taki jak:

(jeśli jakiś warunek
(treść-jeśli-prawda)
(treść-jeśli-fałsz))

Ale poczekaj! Co się stanie, jeśli chcesz wykonać więcej niż jedną instrukcję w treści jednej z nich
te?

Możesz wykonać następujące czynności:

(jeśli (spróbuj-czegoś)
(robić
(wydrukuj „to jest, jeśli to prawda”)
(drukuj „a czemu nie, mówmy dalej o tym, jakie to prawdziwe!))
(wydrukuj „to nadal jest po prostu fałszywe”)

Widać, że skorzystaliśmy do zawijać wiele instrukcji. Jeśli znasz inne
Lipss, jest to odpowiednik program gdzie indziej.

Komentarze zaczynają się od średników:

(wydrukuj „to zadziała”)
; (wydrukuj „ale to nie będzie”)
(+ 1 2 3) ; wykonamy dodanie, ale nie ten komentarz!

Zapętlanie nie jest trudne, ale ma specjalną strukturę. W Pythonie możemy zrobić:

dla mnie zasięg(10):
print „i” jest teraz w „ + str(i)

Odpowiednikiem w Hy byłoby:

(dla [i (zakres 10)]
(print (+ "'i' jest teraz w " (str i))))

Możesz także importować i wykorzystywać różne biblioteki Pythona. Na przykład:

(importuj system operacyjny)

(if (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/innykatalog")
(drukuj „Hej, tej ścieżki tam nie ma!”))

Menedżerowie kontekstu Pythona (w instrukcje) są używane w następujący sposób:

(z [[f (open "/tmp/data.in")]]
(drukuj (.czytaj f)))

co jest równoznaczne z:

z open("/tmp/data.in") jako f:
drukuj f.read()

I tak, mamy wyrażenia listowe! W Pythonie możesz zrobić:

kwadrat szans = [
pow(liczba, 2)
dla numeru in zasięg(100)
jeśli liczba % 2 == 1]

W Hy możesz wykonać następujące czynności:

(setv szanse do kwadratu
(lista-komp
(pow. nr 2)
(liczba (zakres 100))
(= (% liczba 2) 1)))

; I przykład skradziony bezwstydnie ze strony Clojure:
; Wypiszmy wszystkie bloki szachownicy:

(lista-komp
(, xy)
(x (zakres 8)
i „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 obsługuje różne fantazyjne argumenty i argumenty słów kluczowych. W Pythonie moglibyśmy
widzieć:

>>> def opcjonalny_arg(pos1, poz2, słowo kluczowe1=Brak, słowo kluczowe2=42):
... return [pos1, poz2, słowo kluczowe1, słowo kluczowe2]
...
>>> opcjonalny_arg(1, 2)
[1, 2, Brak, 42]
>>> opcjonalny_arg(1, 2, 3, 4)
[1, 2, 3, 4]
>>> opcjonalny_arg(słowo kluczowe1=1, poz.2=2, poz.1=3, słowo kluczowe2=4)
[3, 2, 1, 4]

To samo w Hy:

=> (defn opcjonalny-arg [pos1 poz2 &opcjonalne słowo kluczowe1 [słowo kluczowe2 42]]
... [pos1 poz2 słowo kluczowe1 słowo kluczowe2])
=> (opcjonalny-arg 1 2)
[1 2 Brak 42]
=> (opcjonalny-arg 1 2 3 4)
[1 2 3 4]

Jeśli używasz wersji Hy w wersji starszej niż 0.10.1 (np. git master), dostępna jest także nowa, fajna
Składnia argumentu słowa kluczowego:

=> (opcjonalny-arg :keyword1 1
... :poz2 2
... :poz1 3
... :słowo kluczowe2 4)
[3, 2, 1, 4]

W przeciwnym razie zawsze możesz użyć zastosować. Ale co jest zastosować?

Czy znasz zjawisko przechodzenia? *argumenty i ** kwargs w Pythonie?:

>>> argumenty = [1 2]
>>> kwargs = {"słowo kluczowe2": 3
... "słowo kluczowe1": 4}
>>> opcjonalny_arg(*args, **kwargs)

Możemy to odtworzyć za pomocą zastosować:

=> (setv argumenty [1 2])
=> (setv kwargs {"słowo kluczowe2" 3
... "słowo kluczowe1" 4})
=> (zastosuj opcjonalne-arg args kwargs)
[1, 2, 4, 3]

Istnieje również konstrukcja argumentów słów kluczowych w stylu słownika, która wygląda następująco:

(zdefiniuj inny styl [&klucz {"klucz1" "wartość1" "klucz2" "wartość2"}]
[klucz1 klucz2])

Różnica polega na tym, że ponieważ jest to słownik, nie można polegać na żadnym konkretnym
uporządkowanie argumentów.

Hy również wspiera *argumenty i ** kwargs. W Pythonie:

def jakaś_func(foo, bar, *args, **kwargs):
importuj wydruk
pprint.pprint((foo, bar, argumenty, kwargs))

Odpowiednik Hy:

(defn jakaś-funkcja [foo bar &rest args &kwargs kwargs]
(importuj wydruk)
(pprint.pprint (, foo bar argumenty kwargs)))

W końcu oczywiście potrzebujemy zajęć! W Pythonie możemy mieć klasę taką jak:

klasa FooBar(obiekt):
"" "
Kolejna przykładowa klasa
"" "
def __init__(ja, x):
siebie.x = x

def get_x(ja):
"" "
Zwróć naszą kopię x
"" "
zwróć siebie.x

w Hy:

(defclass FooBar [obiekt]
„Kolejna przykładowa klasa”
[[--w tym--
(fn [samo x]
(setv self.xx)
; Obecnie potrzebne dla --init--, ponieważ __init__ nie potrzebuje żadnego
; Mam nadzieję, że to minie :)
Nic)]

[get-x
(fn [siebie]
„Zwróć naszą kopię x”
siebie.x)]])

Możesz także wykonać atrybuty na poziomie klasy. W Pythonie:

klasa Klient(modele.Model):
nazwa = modele.CharField(max_length=255)
adres = modele.Pole Tekstowe()
notatki = modele.TextField()

w Hy:

(defclass Klient [models.Model]
[[nazwa (models.CharField: maksymalna długość 255})]
[adres (modele.TextField)]
[uwagi (modele.TextField)]])

Hy <-> Python współdziałanie
Importując Hy, możesz używać Hy bezpośrednio z Pythona!

Jeśli zapiszesz następujące informacje w pozdrawiam.hy:

(defn pozdrów [imię] (wypisz „cześć od hy”, imię))

Następnie możesz użyć go bezpośrednio z Pythona, importując hy przed zaimportowaniem modułu. W
Pyton:

importuj hy
importuj pozdrowienia

pozdrowienia.pozdrowienia("Foo")

Możesz także zadeklarować funkcję w Pythonie (lub nawet w klasie!) i użyć jej w Hy!

Jeśli zapiszesz następujące informacje w pozdrowienia.py w Pythonie:

zdecydowanie pozdrawiam (imię):
print("cześć, %s" % (imię))

Możesz go używać w Hy:

(importuj pozdrowienia)
(.pozdrowienia „foo”)

Aby użyć argumentów słów kluczowych, możesz użyć in pozdrowienia.py:

def pozdrawiam(imię, tytuł="Sir"):
print("Witam, %s %s" % (tytuł, imię))

(importuj pozdrowienia)
(.pozdrowienia „Foo”)
(.greet pozdrowienia „Foo” „Darth”)
(zastosuj (.pozdrowienia pozdrawiam) ["Foo"] {"tytuł" "Panie"})

Które wygenerowałoby:

Witam, Panie Foo

Pozdrawiam, Darth Foo

Pozdrawiam, Lordzie Foo

Wskazówki!
Hy zawiera także coś znanego jako „makro gwintowania”, co jest naprawdę przydatną funkcją
Clojure’a. „Makro gwintowania” (zapisane jako ->) służy do uniknięcia głębokiego zagnieżdżenia
wyrażenia.

Makro wątków wstawia każde wyrażenie do pierwszego argumentu następnego wyrażenia
Zamiast.

Weźmy klasykę:

(pętla (drukuj (eval (czytaj)))))

Zamiast pisać to w ten sposób, możemy to zapisać w następujący sposób:

(-> (czytaj) (eval) (drukuj) (pętla))

Teraz, używając python-sh, możemy pokazać, jak makro wątków (ze względu na konfigurację Pythona-sh)
można używać jak rury:

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

Co oczywiście rozszerza się do:

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

Znacznie bardziej czytelne, prawda? Użyj makra gwintowania!

HY STYL krok po kroku

– Wiesz, Ministrze, nie zgadzam się z Dumbledore’em w wielu kwestiach… ale nie możesz zaprzeczyć, że tak jest
mam styl…” – Phineas Nigellus Black, Harry Garncarz i dotychczasowy Zamówienie of dotychczasowy feniks

Przewodnik po stylu Hy ma być zbiorem podstawowych zasad dla Hyve (tak, społeczności Hy
szczyci się dodawaniem Hy do wszystkiego), aby napisać idiomatyczny kod Hy. Hy czerpie wiele
z Clojure i Common Lisp, przy jednoczesnym zachowaniu interoperacyjności Pythona.

Preludium
Połączenia Tao of Hy
Ummon zapytał głównego mnicha: „O jakiej sutrze wykładasz?”
„Sutra Nirwany”.
„Sutra Nirwany ma Cztery Cnoty, prawda?”
"To ma."
Ummon zapytał, podnosząc kubek: „Ile ma to zalet?”
„Wcale” – powiedział mnich.
– Ale starożytni ludzie twierdzili, że tak, prawda? powiedział Ummon.
– Co sądzisz o tym, co powiedzieli?
Umon uderzył w kielich i zapytał: „Rozumiesz?”
„Nie” – powiedział mnich.
„W takim razie” – powiedział Ummon – „lepiej kontynuuj wykłady na temat sutry”.
— makro (koan).

Poniżej przedstawiono krótką listę decyzji projektowych, które wzięły udział w procesie podejmowania
Hy.

· Wyglądaj jak Lisp; DTRT za jego pomocą (np. myślniki zamieniają się w podkreślenia, nauszniki zamieniają się w
wszystkie duże litery).

· Nadal jesteśmy Pythonem. Większość elementów wewnętrznych tłumaczy 1:1 na elementy wewnętrzne Pythona.

· Używaj wszędzie Unicode.

· Napraw błędne decyzje w Pythonie 2, kiedy tylko możemy (patrz prawdziwy_podział).

· W razie wątpliwości skorzystaj z Pythona.

· Jeżeli nadal nie jesteś pewien, skorzystaj z Clojure.

· Jeśli nie jesteś jeszcze bardziej pewien, skorzystaj z Common Lisp.

· Pamiętaj, że nie jesteśmy Clojure. Nie jesteśmy Common Lisp. Jesteśmy homoikonicznym Pythonem, z
dodatkowe bity, które mają sens.

układ & wcięcie
· Unikaj końcowych spacji. Są do bani!

· Wcięcie powinno wynosić 2 spacje (bez twardych tabulatorów), z wyjątkiem dopasowania do wcięcia
poprzednia linia.

;; Dobry (i preferowany)
(określ fib [n]
(jeśli (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Nadal w porządku
(określ fib [n]
(if (<= n 2) n (+ (fib (- n 1)) (fib (- n 2)))))

;; Nadal w porządku
(określ fib [n]
(jeśli (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Histerycznie śmieszne
(określ fib [n]
(jeśli (<= n 2)
N ;; tak, uwielbiam losowo naciskać klawisz spacji
(+ (fib (- n 1)) (fib (- n 2)))))

· Nawiasy muszą nigdy zostać pozostawionym samym sobie, smutnym i samotnym na własnej linii.

;; Dobry (i preferowany)
(określ fib [n]
(jeśli (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Histerycznie śmieszne
(określ fib [n]
(jeśli (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))
)
) ; GAH, SPAL OGNIEM

· Wyrównaj w pionie niech Bloki.

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

· Komentarze wbudowane powinny znajdować się dwie spacje od końca kodu; zawsze muszą mieć
spacja między znakiem komentarza a początkiem komentarza. Spróbuj też tego nie robić
komentować rzeczy oczywiste.

;; Dobry
(setv ind (dec x)) ; indeksowanie zaczyna się od 0

;; Zgodny ze stylem, ale po prostu stwierdza oczywistość
(setv ind (dec x)) ; ustawia indeks na x-1

;; Zły
(setv ind (dec x));wpisywanie słów dla zabawy

Kodowanie Styl
· Zgodnie z konwencją, staraj się nie używać def dla czegokolwiek innego niż zmienne globalne; używać ustaw
wewnętrzne funkcje, pętle itp.

;; Dobry (i preferowany)
(domyślnie *limit* 400000)

(defn fibs [ab]
(choć to prawda
(wydajność a)
(setv (, ab) (, b (+ ab)))))

;; Złe (i nie preferowane)
(defn fibs [ab]
(choć to prawda
(wydajność a)
(def (, ab) (, b (+ ab)))))

· Nie używaj składni wyrażeń s tam, gdzie zamierzona jest składnia wektorowa. Na przykład fakt
pierwszy z tych dwóch przykładów działa tylko dlatego, że kompilator nie jest przesadzony
ścisły. W rzeczywistości poprawna składnia w takich miejscach jak to jest ta druga.

;; Zły (i zły)
( defn foo (x) (drukuj x))
(foo 1)

;; Dobry (i preferowany)
( defn foo [x] (drukuj x))
(foo 1)

· Użyj makra gwintowania lub makra ogona gwintu, gdy napotykasz głęboko zagnieżdżone
s-wyrażenia. Należy jednak zachować rozsądek podczas ich używania. Używaj ich, gdy jasność i
poprawia się czytelność; nie konstruuj zawiłych, trudnych do zrozumienia wyrażeń.

;; Preferowane
(zgodnie z *imionami*
(z [f (otwórz „names.txt”)]
(-> (.read f) (.strip) (.replace "\"" "") (.split ",") (posortowane))))

;; Nie zbyt dobrze
(zgodnie z *imionami*
(z [f (otwórz „names.txt”)]
(posortowane (.split "," (.replace "\"" "" (.strip (.read f)))))))))))

;; Prawdopodobnie nie jest to dobry pomysł
(defn kwadrat? [x]
(->> 2 (pow (int (sqrt x))) (= x)))

· Notacja z kropkami w stylu Clojure jest preferowana w stosunku do bezpośredniego wywołania metody obiektu,
chociaż oba będą nadal obsługiwane.

;; Dobry
(z [fd (otwórz "/ Etc / passwd")]
(drukuj (.readlines fd)))

;; Nie zbyt dobrze
(z [fd (otwórz "/ Etc / passwd")]
(drukuj (fd.readlines)))

Wnioski
„Moda przemija, styl jest wieczny” – Yves Saint Laurent

Ten przewodnik to tylko zbiór wytycznych dla społeczności i oczywiście wytyczne dla społeczności takie właśnie są
nie miałoby sensu bez aktywnej społeczności. Wkłady są mile widziane. Dołącz do nas na #hy in
freenode, pisz o tym na blogu, tweetuj i co najważniejsze, baw się dobrze z Hy.

Podziękowania
· Ten przewodnik jest w dużej mierze zainspirowany @paultag wpis na blogu Hy Przetrwanie przewodnik

· Clojure Styl przewodnik

DOKUMENTACJA INDEKS

Spis treści:

Command Linia Interfejs
hy
Command Linia Opcje
-c
Wykonaj kod Hy w komenda.

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

-i
Wykonaj kod Hy w komenda, a następnie pozostań w REPL.

-m
Wykonaj kod Hy w moduł, w tym defmain jeśli zdefiniowano.

Połączenia -m flaga kończy listę opcji, tak że wszystkie argumenty po moduł Nazwa
są przekazywane do modułu w sys.argv.

Nowość w wersji 0.10.2.

--szpieg Wydrukuj odpowiedni kod Pythona przed wykonaniem. Na przykład:

=> (defn salutationsnm [imię] (print (+ "Hej" imię "!")))
def pozdrawiamnm(imię):
return print(((u'Hy ' + imię) + u'!'))
=> (pozdrowienianm „Twoje imię”)
pozdrowienianm(u'Twoje imię')
Twoje imię!
=>

Nowość w wersji 0.9.11.

--show-tracebacks
Wydrukuj rozszerzone śledzenie dla wyjątków Hy.

Nowość w wersji 0.9.12.

-v Wydrukuj numer wersji Hy i wyjdź.

hyc
Command Linia Opcje
plik[, plikN]
Skompiluj kod Hy do kodu bajtowego Pythona. Na przykład zapisz następujący kod jako
hyname.hy:

(defn hy-hy [imię]
(drukuj (+ „Hej” imię „!”)))

(hy-hy „Afromanin”)

Następnie uruchomić:

$ hyc hyname.hy
$ python hyname.pyc
Cześć Afromanie!

hy2py
Nowość w wersji 0.10.1.

Command Linia Opcje
-s

--ze-źródłem
Pokaż przeanalizowaną strukturę źródłową.

-a

--z-ast
Pokaż wygenerowany AST.

-np

--bez-pythona
Nie pokazuj kodu Pythona wygenerowanego z AST.

Hy ( język)
UWAGA:
To jest niekompletne; prosimy o rozważenie włączenia się w prace związane z dokumentacją.

Teoria of Hy
Hy utrzymuje przede wszystkim 100% kompatybilność w obu kierunkach z Pythonem
samo. Cały kod Hy kieruje się kilkoma prostymi zasadami. Zapamiętaj to, bo to nadejdzie
telefon.

Reguły te pomagają zapewnić, że kod Hy jest idiomatyczny i łatwy w obsłudze w obu językach.

· Symbole w nausznikach zostaną przetłumaczone na wersję tego ciągu pisaną wielkimi literami. Dla
przykład, bla stanie się FOO.

· Podmioty UTF-8 będą kodowane przy użyciu kod puny i poprzedzone prefiksem hy_. Na przykład, ⚘
stanie się hy_w7h, ♥ stanie się hy_g6h, ja♥u stanie się hy_iu_t0x.

· Symbole zawierające myślniki zostaną zastąpione podkreśleniami. Na przykład,
szablon renderowania stanie się szablon_renderowania. Oznacza to, że symbole z myślnikami będą
cieniuj swoje podkreślone odpowiedniki i odwrotnie.

Wbudowane
Hy zawiera wiele specjalnych formularzy, które pomagają wygenerować poprawny kod AST w języku Python.
Poniżej znajdują się formularze „specjalne”, których zachowanie może być nieco nieoczekiwane
niektóre sytuacje.

.
Nowość w wersji 0.10.0.

. służy do uzyskiwania dostępu do atrybutów obiektów. Wykorzystuje małe łącze DSL, aby umożliwić szybkie połączenie
dostęp do atrybutów i elementów w zagnieżdżonej strukturze danych.

Na przykład,

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

Kompiluje się do:

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

. kompiluje swój pierwszy argument (w przykładzie bla) jako obiekt, na którym należy wykonać operację
dereferencja atrybutu. Wykorzystuje nagie symbole jako atrybuty dostępu (w przykładzie bar,
baz, żaba) i kompiluje zawartość list (w przykładzie [(+ 1 2)]) do indeksacji.
Inne argumenty zgłaszają błąd kompilacji.

Dostęp do nieznanych atrybutów powoduje zgłoszenie Błąd atrybutu. Dostęp do nieznanych kluczy powoduje wygenerowanie błędu
Błąd indeksu (na listach i krotkach) lub a Błąd klucza (w słownikach).

->
-> (Lub gwintowanie makro) służy do uniknięcia zagnieżdżania wyrażeń. Makro gwintowania
wstawia każde wyrażenie w miejscu pierwszego argumentu następnego wyrażenia. Następujące
kod to demonstruje:

=> (zdefiniuj wyjście [ab] (drukuj ab))
=> (-> (+ 4 6) (wyjście 5))
10 5

- >>
- >> (Lub gwintowanie ogon makro) jest podobny do gwintowanie makro, ale zamiast
wstawiając każde wyrażenie do pierwszego argumentu następnego wyrażenia, dołącza je jako
ostatni argument. Poniższy kod to demonstruje:

=> (zdefiniuj wyjście [ab] (drukuj ab))
=> (->> (+ 4 6) (wyjście 5))
5 10

zastosować
zastosować służy do zastosowania opcjonalnej listy argumentów i opcjonalnego słownika kwargs
do funkcji.

Stosowanie: (zastosować nazwa-fn [argumenty] [kwargs])

Przykłady:

(definitywnie dziękuję []
„hej”)

(zastosuj, myślę)
;=> „cześć”

(defn całkowity zakup [kwota ceny i opcjonalnie [opłaty 1.05] [vat 1.1]]
(* cena kwota opłaty VAT))

(zastosuj zakup całkowity [10 15])
;=> 173.25

(zastosuj całkowity zakup [10 15] {"vat" 1.05})
;=> 165.375

(zastosuj całkowity zakup [] {"cena" 10 "kwota" 15 "vat" 1.05})
;=> 165.375

i
i jest używany w wyrażeniach logicznych. Przyjmuje co najmniej dwa parametry. Jeśli wszystkie parametry
ocenić do Prawdziwy, zwracany jest ostatni parametr. W każdym innym przypadku pierwsza wartość fałszywa
będzie zwrócony. Przykładowe użycie:

=> (i Prawda Fałsz)
Fałszywy

=> (i prawda prawda)
Prawdziwy

=> (i Prawda 1)
1

=> (i Prawda [] Fałsz Prawda)
[]

UWAGA:
i powoduje zwarcie i przestaje oceniać parametry, gdy tylko pojawi się pierwszy fałsz
napotkany.

=> (i Fałsz (wypisz „cześć”))
Fałszywy

zapewniać
zapewniać służy do sprawdzania warunków podczas działania programu. Jeśli warunek nie jest
spotkałem, an Błąd asercji jest podniesiony. zapewniać może przyjmować jeden lub dwa parametry. Pierwszy
Parametr jest warunkiem do sprawdzenia i powinien przyjąć którykolwiek z nich Prawdziwy or Fałszywy,
drugi parametr, opcjonalny, jest etykietą potwierdzenia i ciągiem znaków, który będzie
podniesiony z Błąd asercji. Na przykład:

(twierdzić (= zmienna wartość oczekiwana))

(potwierdzić fałsz)
; Błąd asercji

(twierdzić (= 1 2) „jeden powinien równać się dwa”)
; AssertionError: jeden powinien równać się dwa

doc
doc służy do powiązania klucza z wartością w słowniku lub do ustawienia indeksu listy
do wartości. Przyjmuje co najmniej trzy parametry: the dane Struktura do modyfikacji, a klucz
or wskaźnikI wartość. Jeżeli użyte zostaną więcej niż trzy parametry, zostaną one skojarzone parami.

Przykłady użycia:

=>(pozwól [[kolekcja {}]]
... (kolekcja zbiorowa „Pies” „Kora”)
... (kolekcja druków))
{u'Pies': u'Szczerze'}

=>(pozwól [[kolekcja {}]]
... (kolekcja zbiorowa „Pies” „Kora” „Kot” „Miau”)
... (kolekcja druków))
{u'Kot': u'Miau', u'Pies': u'Szczerka'}

=>(niech [[kolekcja [1 2 3 4]]]
... (kolekcja asoc 2 Brak)
... (kolekcja druków))
[1, 2, Brak, 4]

UWAGA:
doc modyfikuje strukturę danych w miejscu i zwraca żaden.

złamać
złamać służy do wyjścia z pętli. Natychmiast kończy pętlę. Następujące
przykład ma nieskończoność Podczas pętla, która kończy się w momencie wejścia użytkownika k.

(podczas gdy True (if (= „k” (surowe dane wejściowe „?”)))
(przerwa)
(drukuj „Spróbuj ponownie”)))

dyr
dyr można wykorzystać do budowania zagnieżdżonych if sprawozdania. Poniższy przykład pokazuje
związek pomiędzy makro i jego ekspansją:

(warunek [warunek-1 wynik-1]
[warunek-2 wynik-2])

(jeśli warunek-1 wynik-1
(jeśli warunek-2 wynik-2))

Jak pokazano poniżej, wykonywany jest tylko pierwszy pasujący blok wyników.

=> (zdefiniuj wartość kontrolną [wartość]
... (warunek [(< wartość 5) (wypisz „wartość jest mniejsza niż 5”)]
... [(= wartość 5) (wypisz „wartość jest równa 5”)]
... [(> wartość 5) (wypisz „wartość jest większa niż 5”)]
... [Prawda (wypisz „wartość jest czymś, czym nie powinna być”)]))

=> (wartość kontrolna 6)
wartość jest większa niż 5

kontynuować
kontynuować zwraca wykonanie na początek pętli. W poniższym przykładzie
(efekt uboczny1) jest wywoływana dla każdej iteracji. (efekt uboczny2)jest jednak tylko wywoływany
każdą inną wartość na liście.

;; zakładając, że (efekt uboczny1) i (efekt uboczny2) są funkcjami i
;; kolekcja to lista wartości liczbowych

(dla [x kolekcja]
(robić
(efekt uboczny1 x)
(jeśli (% x 2)
(Kontynuować))
(efekt uboczny2 x)))

dykt-komp
dykt-komp służy do tworzenia słowników. Wymaga trzech lub czterech parametrów. Pierwszy
dwa parametry służą do kontrolowania wartości zwracanej (para klucz-wartość), a trzeci
służy do wybierania elementów z sekwencji. Można użyć czwartego i opcjonalnego parametru
odfiltruj niektóre elementy sekwencji na podstawie wyrażenia warunkowego.

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

do / program
do i program służą do oceny każdego z argumentów i zwrócenia ostatniego. Powrót
wartości z każdego innego argumentu niż ostatni są odrzucane. Można go używać w lambda or
lista-komp wykonać bardziej złożoną logikę, jak pokazano w jednym z poniższych przykładów.

Niektóre przykładowe użycie:

=> (jeśli to prawda
... (zrób (wydrukuj „Skutki uboczne rock!”)
... (drukuj „Tak, naprawdę!”)))
Skutki uboczne rock!
Tak, naprawdę!

;; zakładając, że (efekt uboczny) jest funkcją, którą chcemy wywołać dla każdego
;; i każdą wartość na liście, ale której wartość zwracana nie obchodzi nas
=> (list-comp (do (efekt uboczny x)
... (jeśli (< x 5) (* 2 x)
... (* 4x)))
... (x (zakres 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do może przyjąć dowolną liczbę argumentów od 1 do n.

def / ustaw
def i ustaw służą do powiązania wartości, obiektu lub funkcji z symbolem. Na przykład:

=> (def. imiona ["Alicja" "Bob" "Charlie"])
=> (drukuj nazwy)
[ty, Alicja, Bob, Charlie]

=> (licznik setv (fn [element kolekcji] (element kolekcji .count))))
=> (licznik [1 2 3 4 5 2 3] 2)
2

złamać klasę
Nowe klasy deklarowane są za pomocą złamać klasę. Może przyjmować dwa opcjonalne parametry: wektor
zdefiniowanie możliwych superklas i kolejnego wektora zawierającego atrybuty nowego
klasę jako dwa wektory elementów.

(defclass nazwa-klasy [super-klasa-1 super-klasa-2]
[[wartość atrybutu]])

Zarówno wartości, jak i funkcje można powiązać z nową klasą, jak pokazano w poniższym przykładzie:

=> (defclass Cat []
... [[wiek brak]
... [kolor „biały”]
... [mów (fn [self] (drukuj „Miau”))]])

=> (zdecydowanie miejsce (Kot))
=> (ustawiony kolor punktowy „Czarny”)
'Czarny'
=> (.speak miejsce)
Miauczeć

zdefiniuj / definitywny
zdefiniuj i definitywny makra służą do definiowania funkcji. Przyjmują trzy parametry: Nazwa
funkcji do zdefiniowania, wektor parametryi ciało funkcji:

(nazwa domyślna [params] ciało)

Parametry mogą mieć przed sobą następujące słowa kluczowe:

&opcjonalny
Parametr jest opcjonalny. Parametr można podać w postaci listy dwóch pozycji, gdzie
pierwszy element to nazwa parametru, a drugi to wartość domyślna. Parametr
można również podać jako pojedynczy element, w takim przypadku wartością domyślną jest żaden.

=> (defn wartość całkowita [wartość i opcjonalna [podatek od wartości dodanej 10]]
... (+ (/ (* wartość podatku VAT) 100) wartość))

=> (wartość całkowita 100)
110.0

=> (wartość całkowita 100 1)
101.0

&klucz

&kwargs
Parametr będzie zawierał 0 lub więcej argumentów słów kluczowych.

Poniższe przykłady kodu definiują funkcję, która wyświetli wszystkie słowa kluczowe
Argumenty i ich wartości.

=> (defn parametry drukowania [&kwargs kwargs]
... (dla [(, kv) (.items kwargs)] (drukuj kv)))

=> (zastosuj parametry drukowania [] {"parametr-1" 1 "parametr-2" 2})
parametr-2 2
parametr-1 1

&odpoczynek Parametr będzie zawierał 0 lub więcej argumentów pozycyjnych. Żadne inne położenie
argumenty można podać po tym.

Poniższy przykład kodu definiuje funkcję, której można nadać wartość liczbową od 0 do n
parametry. Następnie sumuje każdą liczbę nieparzystą i odejmuje każdą liczbę parzystą.

=> (defn zig-zag-sum [&pozostałe liczby]
(let [[liczby-nieparzyste (list-comp x [x liczby] (nieparzyste? x))]
[liczby-parzyste (list-comp x [x liczby] (parzyste? x))]]
(- (suma liczb nieparzystych) (suma liczb parzystych))))

=> (suma zygzakowata)
0
=> (suma zygzakowata 3 9 4)
8
=> (suma zygzakowata 1 2 3 4 5 6)
-3

defn-alias / defun-alias
Nowość w wersji 0.10.0.

Połączenia defn-alias i defun-alias makro jest bardzo podobne zdefiniuj, z rozróżnieniem, że
zamiast definiować funkcję o pojedynczej nazwie, mogą one również definiować aliasy. Inny
niż przyjęcie listy symboli nazw funkcji jako pierwszego parametru, defn-alias i
defun-alias nie różnią się od zdefiniuj i definitywny.

=> (defn-alias [alias głównej nazwy] []
... (drukuj „Witam!”))
=> (główne imię)
"Cześć!"
=> (alias)
"Cześć!"

defmain
Nowość w wersji 0.10.1.

Połączenia defmain makro definiuje główną funkcję, która jest natychmiast wywoływana sys.argv as
argumenty wtedy i tylko wtedy, gdy ten plik jest wykonywany jako skrypt. Innymi słowy, to:

(defmain [&reszta argumentów]
(zrób coś z argumentami))

jest odpowiednikiem:

def main(*args):
zrobić_coś_z(argumentami)
zwróć 0

if __name__ == "__main__":
import sys
retval = main(*sys.arg)

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

Zauważ, że jak widać powyżej, jeśli zwrócisz liczbę całkowitą z tej funkcji, tak będzie
używany jako status wyjścia skryptu. (Python domyślnie opuszcza status 0, w przeciwnym razie
co oznacza, że ​​wszystko jest w porządku!)

(Odkąd (sys.exit 0) nie jest uruchamiany jawnie w przypadku niecałkowitego zwrotu z
defmain, warto to umieścić (zdefiniowany) jako ostatni fragment kodu w pliku.)

defmakro
defmakro służy do definiowania makr. Ogólny format to (defmakro Nazwa [parametry]
wyraż).

Poniższy przykład definiuje makro, którego można użyć do zamiany kolejności elementów w kodzie,
umożliwiając użytkownikowi pisanie kodu w notacji infiksowej, gdzie operator znajduje się pomiędzy
operandy.

=> (infix defmacro [kod]
... (quasicyt (
... (usuń cudzysłów (pobierz kod 1))
... (usuń cudzysłów (pobierz kod 0))
... (usuń cudzysłów (pobierz kod 2)))))

=> (wrostek (1 + 1))
2

defmacro-alias
defmacro-alias służy do definiowania makr o wielu nazwach (aliasach). Ogólny format
is (defmacro-alias [nazwy] [parametry] wyraż). Tworzy wiele makr z tym samym
lista parametrów i treść pod określoną listą nazw.

Poniższy przykład definiuje dwa makra, z których oba umożliwiają użytkownikowi pisanie kodu
notacja infiksowa.

=> (defmacro-alias [infix infi] [kod]
... (quasicyt (
... (usuń cudzysłów (pobierz kod 1))
... (usuń cudzysłów (pobierz kod 0))
... (usuń cudzysłów (pobierz kod 2)))))

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

defmakro/g!
Nowość w wersji 0.9.12.

defmakro/g! to specjalna wersja defmakro który jest używany do automatycznego generowania gensym
dla dowolnego symbolu zaczynającego się od g!.

Na przykład, g!a stanie się (gensym "A").

ZOBACZ TAKŻE:
Sekcja using-gensym

defreader
Nowość w wersji 0.9.12.

defreader definiuje makro czytnika, umożliwiające restrukturyzację lub modyfikację składni.

=> (defreader ^ [wyraż] (wydrukuj wyrażenie))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Witam"
"Cześć"

ZOBACZ TAKŻE:
Makra czytnika sekcji

del
Nowość w wersji 0.9.12.

del usuwa obiekt z bieżącej przestrzeni nazw.

=> (setv foo 42)
=> (del foo)
=> fuj
Traceback (ostatnie połączenie ostatnio):
Plik " ", wiersz 1, w
NameError: nazwa „foo” nie jest zdefiniowana

del może także usuwać obiekty z map, list i nie tylko.

=> (test setv (lista (zakres 10)))
=> testuj
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (del (test plastra 2 4)) ;; usuń elementy od 2 do 4 wykluczone
=> testuj
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "bar"})
=> dyk
{"foo": "pasek"}
=> (del (pobierz dic „foo”))
=> dyk
{}

zrobić, aby
Nowość w wersji 0.10.1.

zrobić, aby służy do uproszczenia sekwencji wywołań metod do obiektu.

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

=> (kolekcja setv [])
=> (.append kolekcja 1)
=> (.append kolekcja 2)
=> (kolekcja .reverse)
=> kolekcja
[2 1]

eval
eval ocenia cytowane wyrażenie i zwraca wartość.

=> (eval '(drukuj "Hello World"))
"Witaj świecie"

ewaluuj i kompiluj
ewaluuj podczas kompilacji
drugim / wózek
drugim i wózek to makra umożliwiające dostęp do pierwszego elementu kolekcji:

=> (pierwszy (zakres 10))
0

dla
dla służy do wywoływania funkcji dla każdego elementu listy lub wektora. Wyniki każdego
połączenie zostanie odrzucone, a dla wyrażenie zwraca żaden Zamiast. Przykładowy kod iteruje
koniec kolekcja i dla każdego element in kolekcja wzywa efekt uboczny funkcja z
element jako argument:

;; zakładając, że (efekt uboczny) jest funkcją, która przyjmuje pojedynczy parametr
(dla [kolekcja elementów] (element efektu ubocznego))

;; for może mieć opcjonalny blok else
(dla [kolekcja elementów] (element efektu ubocznego)
(w przeciwnym razie (efekt uboczny-2)))

Opcjonalne więcej blok jest wykonywany tylko wtedy, gdy dla pętla kończy się normalnie. Jeśli
wykonanie zostaje wstrzymane złamaćThe więcej blok nie jest wykonywany.

=> (dla [element [1 2 3]] (if (< element 3)
... (element druku)
... (przerwa))
... (else (drukuj „pętla zakończona”)))
1
2

=> (dla [element [1 2 3]] (if (< element 4)
... (element druku)
... (przerwa))
... (else (drukuj „pętla zakończona”)))
1
2
3
pętla zakończona

rodzajwyr
rodzajwyr służy do tworzenia wyrażeń generatora. Wymaga dwóch lub trzech parametrów. The
pierwszy parametr jest wyrażeniem kontrolującym wartość zwracaną, natomiast drugi jest używany
aby wybrać elementy z listy. Trzeciego i opcjonalnego parametru można użyć do odfiltrowania
niektóre pozycje na liście są oparte na wyrażeniu warunkowym. rodzajwyr jest podobne do
lista-komp, z tą różnicą, że zwraca iterowalną wartość, która zamiast tego ocenia wartości jedna po drugiej
natychmiast je oceniając.

=> (def kolekcja (zakres 10))
=> (def filtrowane (genexpr x [x kolekcja] (parzyste? x)))
=> (lista przefiltrowana)
[0, 2, 4, 6, 8]

gensym
Nowość w wersji 0.9.12.

gensym służy do generowania unikalnego symbolu, który umożliwia pisanie makr bez
przypadkowe kolizje nazw zmiennych.

=> (gensym)
u':G_1235'

=> (gensym „x”)
ty':x_1236'

ZOBACZ TAKŻE:
Sekcja using-gensym

otrzymać
otrzymać służy do uzyskiwania dostępu do pojedynczych elementów na listach i słownikach. otrzymać przyjmuje dwa parametry:
dotychczasowy dane Struktura oraz wskaźnik or klucz przedmiotu. Następnie zwróci odpowiednią wartość
wartość ze słownika lub listy. Przykładowe użycie:

=> (pozwól [[zwierzęta {"pies" "szczekać" "kot" "miau"}]
... [cyfry [„zero” „jeden” „dwa” „trzy”]]]
... (drukuj (pobierz zwierzęta „pies”))
... (wydrukuj (pobierz liczby 2)))
kora
drugiej

UWAGA:
otrzymać wywołuje KeyError, jeśli słownik jest pytany o nieistniejący klucz.

UWAGA:
otrzymać wywołuje błąd IndexError, jeśli lista lub krotka jest pytana o indeks, którego nie ma
miedza.

światowy
światowy można użyć do oznaczenia symbolu jako globalnego. Dzięki temu programista może przypisać a
wartość na symbol globalny. Odczytywanie symbolu globalnego nie wymaga światowy słowo kluczowe --
robi to tylko przypisanie.

Poniższy przykład pokazuje, jak symbol globalny a ma przypisaną wartość w funkcji i
jest później drukowany w innej funkcji. Bez światowy słowo kluczowe, druga funkcja
rzuciłby A NazwaBłąd.

(defn set-a [wartość]
(globalny a)
(ustaw wartość))

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

(ustaw-a 5)
(drukuj-a)

if / Jeśli nie
Nowość w wersji 0.10.0: jeśli-nie

if służy do warunkowego wyboru kodu do wykonania. Musi zawierać warunek
blok i blok, który ma zostać wykonany, jeśli blok warunku ma wartość Prawdziwy. Opcjonalnie,
może zawierać blok końcowy, który jest wykonywany w przypadku oceny warunku
Fałszywy.

Jeśli nie jest podobny, ale drugi blok zostanie wykonany, gdy warunek nie powiedzie się while
trzeci i ostatni blok jest wykonywany, gdy test się powiedzie – w odwrotnej kolejności if.

Przykładowe użycie:

(jeśli (zostały pieniądze? na koncie)
(wydrukuj „chodźmy na zakupy”)
(wydrukuj „chodźmy i pracujmy”)

(jeśli-nie (pozostały pieniądze? konto)
(wydrukuj „chodźmy i pracuj”)
(wydrukuj „chodźmy na zakupy”)

Prawdziwość Pythona jest szanowana. żaden, Fałszywy, zero dowolnego typu liczbowego, pusta sekwencja,
i pusty słownik są brane pod uwagę Fałszywy; wszystko inne jest brane pod uwagę Prawdziwy.

seplenienie, jeśli / lif i seplenienie, jeśli nie / nie
Nowość w wersji 0.10.0.

Nowość w wersji 0.10.2: lisp-if-not / lif-not

Dla tych, którzy wolą bardziej Lispy if klauzulę, mamy seplenienie, jeślilub lif, To tylko rozważa
żaden / zero być fałszywe! Wszystkie inne „fałszywe” wartości Pythona są uważane za prawdziwe.
I odwrotnie, mamy seplenienie, jeśli nie i nie równolegle do if i Jeśli nie co odwraca
porównanie.

=> (seplenienie, jeśli prawda „prawda” „fałsz”)
"True"
=> (seplenienie-jeśli fałsz „prawda” „fałsz”)
"True"
=> (lisp-jeśli 0 „prawda” „fałsz”)
"True"
=> (seplenienie, jeśli zero „prawda” „fałsz”)
"fałszywe"
=> (seplenienie, jeśli Brak „prawda” „fałsz”)
"fałszywe"
=> (seplenienie, jeśli nie zero „prawda” „fałsz”)
"True"
=> (lisp-if-not None „true” „false”)
"True"
=> (seplenienie, jeśli nie Fałsz „prawda” „fałsz”)
"fałszywe"

; Odpowiednik, ale krótszy
=> (lif Prawda „prawda” „fałsz”)
"True"
=> (lif nil „prawda” „fałsz”)
"fałszywe"
=> (lif-not None „true” „false”)
"True"

importować
importować służy do importowania modułów, tak jak w Pythonie. Jest na to kilka sposobów importować mogą
być użytym.

;; Importuje każdy z tych modułów
;;
;; Pyton:
;; importuj sys
;; zaimportuj ścieżkę os
(import systemu operacyjnego.ścieżka)

;; Importuj z modułu
;;
;; Python: z os.path istnieje import, isdir, isfile
(import [os.ścieżka [istnieje plik isdir]])

;; Importuj z aliasem
;;
;; Python: zaimportuj sys jako system
(importuj [sys :as system])

;; Możesz wyświetlić dowolną liczbę importów różnych typów.
(importuj [testy.resources [kwtest-funkcja-z-myślnikiem]]
[os.ścieżka [istnieje plik isdir]]
[sys: jako system])

;; Zaimportuj wszystkie funkcje modułu do bieżącej przestrzeni nazw
(importuj [sys [*]])

lambda / fn
lambda i fn można użyć do zdefiniowania funkcji anonimowej. Parametry są podobne
zdefiniuj: pierwszy parametr jest wektorem parametrów, a reszta jest treścią
funkcja. lambda zwraca nową funkcję. W poniższym przykładzie funkcja anonimowa
jest zdefiniowany i przekazywany do innej funkcji w celu filtrowania danych wyjściowych.

=> (def ludzie [{:name "Alice" :age 20}
... {:name "Bob" :wiek 25}
... {:imię "Charlie": wiek 50}
... {:imię "Dave" :wiek 5}])

=> (defn display-people [filtr osób]
... (dla [osoba osoby] (if (filtr osoba) (print (:imię osoby)))))

=> (wyświetl-ludzie ludzie (fn [osoba] (< (:age person) 25)))
Alicja
Dave

Podobnie jak w normalnych definicjach funkcji, jeśli pierwszym elementem treści jest ciąg znaków, to
służy jako dokumentacja. Jest to przydatne do podawania dokumentów metod klasowych.

=> (setv razy-trzy
... (fn [x]
... „Mnoży wprowadzone dane przez trzy i zwraca wynik.”
... (* x 3)))

Można to potwierdzić za pomocą wbudowanej funkcji Pythona pomoc funkcjonować:

=> (pomoc razy trzy)
Pomoc dotycząca funkcji times_three:

razy_trzy(x)
Mnoży dane wejściowe przez trzy i zwraca wynik
(KOŃCZYĆ SIĘ)

trwać
Nowość w wersji 0.10.2.

trwać można użyć do uzyskania dostępu do ostatniego elementu kolekcji:

=> (ostatnie [2 4 6])
6

niech
niech służy do tworzenia zmiennych o zasięgu leksykalnym. Tworzą się na początku
niech formie i przestaje istnieć po formie. Poniższy przykład ilustruje to
zachowanie:

=> (pozwól [[x 5]] (wydrukuj x)
... (niech [[x 6]] (drukuj x))
... (drukuj x))
5
6
5

Połączenia niech makro przyjmuje dwa parametry: wektor definiujący zmienne oraz ciało który dostaje
wykonany. zmienne jest wektorem, w którym każdy element jest pojedynczą zmienną lub wektorem
zdefiniowanie pary wartości zmiennych. W przypadku pojedynczej zmiennej przypisuje się jej wartość
żaden; w przeciwnym razie używana jest podana wartość.

=> (pozwól [x [y 5]] (wydrukuj xy))
Brak 5

lista-komp
lista-komp wykonuje wyrażenia listowe. Wymaga dwóch lub trzech parametrów. Pierwszy
parametr jest wyrażeniem kontrolującym wartość zwracaną, podczas gdy drugi jest do tego przyzwyczajony
wybierz elementy z listy. Trzeciego i opcjonalnego parametru można użyć do odfiltrowania niektórych
pozycji na liście na podstawie wyrażenia warunkowego. Kilka przykładów:

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

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

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

nie
nie jest używany w wyrażeniach logicznych. Pobiera pojedynczy parametr i zwraca wartość odwróconą
wartość prawdy. Jeśli Prawdziwy jest podawany jako parametr, Fałszywy zostaną zwrócone i odwrotnie.
Przykładowe użycie:

=> (nieprawda)
Fałszywy

=> (nie fałsz)
Prawdziwy

=> (nie Brak)
Prawdziwy

or
or jest używany w wyrażeniach logicznych. Przyjmuje co najmniej dwa parametry. Zwróci
pierwszy parametr inny niż fałszywy. Jeżeli taka wartość nie istnieje, zostanie zwrócony ostatni parametr.

=> (lub Prawda Fałsz)
Prawdziwy

=> (i Fałsz Fałsz)
Fałszywy

=> (i Fałsz 1 Prawda Fałsz)
1

UWAGA:
or powoduje zwarcie i przestaje analizować parametry, gdy tylko pojawi się pierwsza wartość prawdziwa
napotkany.

=> (lub True (wydrukuj „cześć”))
Prawdziwy


służy do wyświetlania na ekranie. Przykładowe użycie:

(drukuj „Witaj, świecie!”)

UWAGA:
zawsze wraca żaden.

quasicytat
quasicytat pozwala zacytować formularz, ale także wybiórczo oceniać wyrażenia.
Wyrażenia wewnątrz a quasicytat można selektywnie oceniać za pomocą zamknąć cudzysłów (~).
ocenianą formę można również łączyć za pomocą usuń cudzysłów (~@). Quasicytat może być również
napisane przy użyciu cudzysłowu (`symbol ).

;; niech `qux' będzie zmienną z wartością (bar baz)
`(foo ~qux)
; odpowiednik '(foo (bar baz))
`(foo ~@qux)
; odpowiednik „(foo bar baz)

zacytować
zacytować zwraca przekazany mu formularz bez jego oceny. zacytować alternatywnie może być
pisane przy użyciu apostrofu ('symbol ).

=> (setv x '(drukuj „Hello World”))
; zmienna x jest ustawiona na wyrażenie i nie jest oceniana
=> x
(drukujesz, witasz, świecie)
=> (wartość x)
Witaj świecie

wymagać
wymagać służy do importu makr z danego modułu. Pobiera co najmniej jeden parametr
określenie modułu, które makra mają zostać zaimportowane. Można importować wiele modułów
z jednym wymagać.

Poniższy przykład zaimportuje makra z moduł 1 i moduł 2:

(wymaga modułu-1, modułu-2)

reszta / CDR
reszta i CDR zwróć kolekcję przekazaną jako argument bez pierwszego elementu:

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

zestaw-komp
zestaw-komp służy do tworzenia zestawów. Wymaga dwóch lub trzech parametrów. Pierwszym parametrem jest
do kontrolowania wartości zwracanej, podczas gdy drugi służy do wybierania elementów z a
sekwencja. Trzeciego i opcjonalnego parametru można użyć do odfiltrowania niektórych elementów
sekwencja oparta na wyrażeniu warunkowym.

=> (dane zestawu [1 2 3 4 5 2 3 4 5 3 4 5])
=> (set-comp x [x dane] (nieparzyste? x))
{1, 3, 5}

kawałek
kawałek można użyć do pobrania podzbioru listy i utworzenia z niego nowej listy. Formularz
pobiera co najmniej jeden parametr określający listę do wycięcia. Mogą być dwa opcjonalne parametry
używany do podania pozycji początkowej i końcowej podzbioru. Jeżeli nie zostaną one dostarczone,
domyślna wartość żaden zostanie użyty zamiast tego. Do tego używany jest trzeci opcjonalny parametr
krok kontrolny pomiędzy elementami.

kawałek podlega tym samym zasadom, co jego odpowiednik w Pythonie. Liczone są wskaźniki ujemne
zaczynając od końca listy. Niektóre przykładowe użycie:

=> (def kolekcja (zakres 10))

=> (kolekcja kawałków)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=> (kolekcja plasterków 5)
[5, 6, 7, 8, 9]

=> (kolekcja plasterków 2 8)
[2, 3, 4, 5, 6, 7]

=> (kolekcja kawałków 2 8 2)
[2, 4, 6]

=> (kolekcja plasterków -4 -2)
[6, 7]

rzucać / podnieść
Połączenia rzucać or podnieść formularzy można użyć do podniesienia Wyjątek W czasie wykonywania. Przykładowe użycie:

(rzucić)
; ponownie wykonaj ostatni wyjątek

(wyrzuć błąd IO)
; Wyrzuć błąd IOError

(rzut (IOError "foobar"))
; Zgłoś błąd IOError("foobar")

rzucać może zaakceptować pojedynczy argument (an Wyjątek klasa lub instancja) lub brak argumentów
ponownie podnieś ostatni Wyjątek.

próbować
Połączenia próbować formularz służy do rozpoczęcia a próbować / łapać blok. Formularza używa się w następujący sposób:

(próbować
(funkcja podatna na błędy)
(złap [e ZeroDivisionError] (wypisz „Dzielenie przez zero”)
(w przeciwnym razie (wydrukuj „bez błędów”))
(wreszcie (drukuj „wszystko gotowe”)))

próbować musi zawierać co najmniej jeden łapać blok i opcjonalnie może zawierać plik więcej or w końcu
blok. Jeśli podczas wykonywania zostanie zgłoszony błąd związany z pasującym blokiem catch
funkcja podatna na błędy, Które łapać blok zostanie wykonany. Jeśli nie zostaną zgłoszone żadne błędy, plik więcej
blok jest wykonywany. The w końcu blok zostanie wykonany jako ostatni, niezależnie od tego, czy an
został zgłoszony błąd.

chyba że
Połączenia chyba że makro jest skrótem oznaczającym pisanie pliku if instrukcja sprawdzająca, czy podano
warunkowe jest Fałszywy. Poniżej przedstawiono rozwinięcie tego makra.

(chyba że instrukcja warunkowa)

(jeśli warunkowo
żaden
(zrób oświadczenie))

zamknąć cudzysłów
W formie quasicytowanej, zamknąć cudzysłów wymusza ocenę symbolu. zamknąć cudzysłów jest aliasem
tylda (~symbol ).

(nazwa defensywna „Cuddles”)
(quasicytat (= nazwa (usuń cudzysłów)))
;=> (u'=' twoje imię' u'Cuddles')

`(= imię ~ imię)
;=> (u'=' twoje imię' u'Cuddles')

usuń cudzysłów
usuń cudzysłów wymusza ocenę symbolu w formie quasicytowanej, podobnie jak
zamknąć cudzysłów. usuń cudzysłów można użyć tylko wtedy, gdy symbol niecytowany zawiera znak
iterowalna wartość, ponieważ „splata” tę iterowalną wartość w formie quasicytowanej. usuń cudzysłów is
alias do ~@ symbol.

(domyślnie liczby [1 2 3 4])
(quasicytat (+ (liczba cudzysłowów i splotów)))
;=> (u'+' 1L 2L 3L 4L)

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

jeśli chodzi o komunikację i motywację
jeśli chodzi o komunikację i motywację jest podobne do chyba że, z wyjątkiem tego, że testuje, gdy dany warunek jest Prawdziwy. Nie jest
możliwe, że mam więcej blok w A jeśli chodzi o komunikację i motywację makro. Poniżej przedstawiono rozwinięcie
makro.

(kiedy instrukcja warunkowa)

(jeśli warunkowe (wykonaj instrukcję))

Podczas
Podczas służy do wykonania jednego lub większej liczby bloków, o ile spełniony jest warunek. Następujące
przykład wyświetli komunikat „Witaj, świecie!” na ekran w nieskończoność:

(podczas gdy Prawda (wydrukuj „Witaj, świecie!”))

w
w służy do zawinięcia wykonania bloku w menedżerze kontekstu. Kontekst
menedżer może następnie skonfigurować system lokalny i zniszczyć go w kontrolowany sposób. The
archetypowy przykład użycia w jest podczas przetwarzania plików. w może powiązać kontekst z
argumentu lub całkowicie go zignorować, jak pokazano poniżej:

(z blokiem [[arg (expr)]])

(z blokiem [[(wyrażenie)]])

(z blokiem [[arg (wyrażenie)] [(wyrażenie)]])

Poniższy przykład otworzy plik AKTUALNOŚCI plik i wydrukuj jego zawartość na ekranie. The
plik jest automatycznie zamykany po przetworzeniu.

(z [[f (otwórz „NEWS”)]] (drukuj (.read f)))

z dekoratorem
z dekoratorem służy do owijania funkcji inną. Funkcja wykonująca
dekoracja powinna przyjmować jedną wartość: dekorowaną funkcję i zwracać nową
funkcja. z dekoratorem przyjmuje minimum dwa parametry: wykonywaną funkcję
dekoracja i funkcja dekorowania. Może być więcej niż jedna funkcja dekoratora
stosowany; będą stosowane w kolejności od najbardziej zewnętrznych do najbardziej wewnętrznych, tj. pierwszy
dekorator będzie najbardziej zewnętrznym i tak dalej. Dekoratory posiadające argumenty nazywane są just
jak wywołanie funkcji.

(z-dekoratorem-dekoratorem-zabawą
(zdefiniuj jakąś funkcję [] ...)

(z dekoratorem dekorator1 dekorator2 ...
(zdefiniuj jakąś funkcję [] ...)

(z-dekoratorem (dekorator arg) ..
(zdefiniuj jakąś funkcję [] ...)

W poniższym przykładzie Inc-dekorator służy do dekoracji funkcji dodatek z
funkcja, która przyjmuje dwa parametry i wywołuje funkcję dekorowaną z wartościami, które są
zwiększane o 1. Gdy dekorowane dodatek jest wywoływany z wartościami 1 i 1, koniec
wynik będzie 4 (1 + 1 + 1 + 1).

=> (defn inc-dekorator [funkcja]
... (fn [wartość-1 wartość-2] (func (+ wartość-1 1) (+ wartość-2 1))))
=> (defn inc2-dekorator [funkcja]
... (fn [wartość-1 wartość-2] (func (+ wartość-1 2) (+ wartość-2 2))))

=> (z-dekoratorem inc-dekoratorem (defn dodatek [ab] (+ ab)))
=> (dodanie 1 1)
4
=> (z-dekoratorem inc2-dekoratorem inc-dekoratorem
... ( defn dodatek [ab] (+ ab)))
=> (dodanie 1 1)
8

z-gensymami
Nowość w wersji 0.9.12.

z-gensym służy do generowania zestawu gensym do wykorzystania w makrze. Poniższy kod:

(z-gensymami [abc]
...)

rozwija się do:

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

ZOBACZ TAKŻE:
Sekcja using-gensym

wydajność
wydajność służy do tworzenia obiektu generatora, który zwraca jedną lub więcej wartości. Generator
jest iterowalny i dlatego można go używać w pętlach, wyrażeniach listowych i innych podobnych
konstrukcje.

Funkcja losowe liczby pokazuje, jak można wykorzystać generatory do generowania nieskończonych szeregów
bez zużywania nieskończonej ilości pamięci.

=> (defn pomnóż [podstawowe współczynniki]
... (dla [[(, współczynnik bazowy) (współczynniki bazowe zip)]]
... (wydajność (* współczynnik bazowy))))

=> (pomnóż (zakres 5) (zakres 5))


=> (wartość listy [wartość (pomnóż (zakres 10) (zakres 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (importuj losowo)
=> (zdefiniuj liczby-losowe [nisko wysokie]
... (podczas gdy True (wydajność (.randint losowy niski wysoki)))))
=> (list-comp x [x (weź 15 (liczby losowe 1 50))])])
[7, 41, 6, 22, 32, 17, 5, 38, 18, 38, 17, 14, 23, 23, 19]

plon-z
Nowość w wersji 0.9.13.

PYTON 3.3 ROLNICZE UP TYLKO!

plon-z służy do wywoływania podgeneratora. Jest to przydatne, jeśli chcesz, aby twoja współprogramowalna funkcja to robiła
być w stanie delegować swoje procesy do innej procedury, powiedzmy, jeśli używasz czegoś wymyślnego, np
asyncio.

Hy rdzeń
rdzeń Funkcje
przedostatni
Stosowanie: (ostatni kol.)

Zwraca iterator wszystkich elementów oprócz ostatniego pot.

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

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

=> (lista (butlast []))
[]

=> (importuj narzędzia itertools)
=> (lista (weź 5 (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

kol?
Nowość w wersji 0.10.0.

Stosowanie: (co? x)

Returns Prawdziwy if x jest iterowalny, a nie ciąg znaków.

=> (co? [1 2 3 4])
Prawdziwy

=> (co? {"a" 1 "b" 2})
Prawdziwy

=> (co? „abc”)
Fałszywy

minusy
Nowość w wersji 0.10.0.

Stosowanie: (Cons a b)

Zwraca nową komórkę z wadami wraz z samochodem a i kdr b.

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

=> (= 'hd (samochód a))
Prawdziwy

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

idioci?
Nowość w wersji 0.10.0.

Stosowanie: (Cons? bla)

Sprawdza czy bla jest komórką przeciw.

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

=> (wady? a)
Prawdziwy

=> (wady? zero)
Fałszywy

=> (wady? [1 2 3])
Fałszywy

grudzień
Stosowanie: (grudzień x)

Zwraca o jeden mniej niż x. Równoważny (- x 1). Podnosi Wpisz błąd if (nie jesteś (numeryczne? X)).

=> (3 grudnia)
2

=> (0 grudnia)
-1

=> (12.3 grudnia)
11.3

demontować
Nowość w wersji 0.10.0.

Stosowanie: (demontować drzewo &opcjonalny [kodgen FAŁSZ])

Zrzuć Python AST dla danego Hy drzewo na standardowe wyjście. Jeśli kodogen is Prawdziwy, funkcja
zamiast tego wypisuje kod Pythona.

=> (deasembluj '(drukuj „Hello World!”))
Moduł(
ciało=[
Expr(value=Call(func=Nazwa(id='print'), args=[Str(s='Hello World!')], słowa kluczowe=[], starargs=Brak, kwargs=Brak))])

=> (deasembluj '(drukuj „Hello World!”) true)
print('Witaj, świecie!')

pusty?
Stosowanie: (pusty? kol.)

Returns Prawdziwy if pot jest pusty. Równoważny (= 0 (dł kol)).

=> (pusty? [])
Prawdziwy

=> (pusty? „”)
Prawdziwy

=> (pusty? (, 1 2))
Fałszywy

każdy?
Nowość w wersji 0.10.0.

Stosowanie: (każdy? pred kol.)

Returns Prawdziwy if (przed x) jest logiczne i prawdziwe dla każdego x in pot, W przeciwnym razie Fałszywy. Powrót Prawdziwy
if pot jest pusty.

=> (każdy? nawet? [2 4 6])
Prawdziwy

=> (każdy? nawet? [1 3 5])
Fałszywy

=> (każdy? nawet? [2 4 5])
Fałszywy

=> (każdy? nawet? [])
Prawdziwy

platforma?
Stosowanie: (platforma? x)

Returns Prawdziwy if x jest pływakiem.

=> (pływający? 3.2)
Prawdziwy

=> (pływający? -2)
Fałszywy

parzysty?
Stosowanie: (nawet? x)

Returns Prawdziwy if x jest równa. Podnosi Wpisz błąd if (nie jesteś (numeryczne? X)).

=> (nawet? 2)
Prawdziwy

=> (nawet? 13)
Fałszywy

=> (nawet? 0)
Prawdziwy

tożsamość
Stosowanie: (tożsamość x)

Zwraca argument dostarczony do funkcji.

=> (tożsamość 4)
4

=> (lista (tożsamość mapy [1 2 3 4]))
[1 2 3 4]

inc
Stosowanie: (w tym x)

Zwraca o jeden więcej niż x. Równoważny (+ x 1). Podnosi Wpisz błąd if (nie jesteś (numeryczne? X)).

=> (w tym 3)
4

=> (w tym 0)
1

=> (w tym 12.3)
13.3

instancja?
Stosowanie: (instancja? klasa x)

Returns Prawdziwy if x jest przykładem klasa.

=> (instancja? float 1.0)
Prawdziwy

=> (instancja? int 7)
Prawdziwy

=> (instancja? str (str "foo"))
Prawdziwy

=> (defclass TestClass [obiekt])
=> (setv inst (Klasa Testowa))
=> (instancja? TestClass inst)
Prawdziwy

liczba całkowita?
Stosowanie: (liczba całkowita? x)

Returns Prawdziwy if x jest liczbą całkowitą. W przypadku Pythona 2 jest to albo int or długie. W przypadku Pythona 3
to jest int.

=> (liczba całkowita? 3)
Prawdziwy

=> (liczba całkowita? -2.4)
Fałszywy

przekładać
Nowość w wersji 0.10.1.

Stosowanie: (przekładać nast.1 nast.2 ...)

Zwraca iterowalną wartość pierwszego elementu w każdej sekwencji, następnie drugiego itd.

=> (lista (przeplatanie (zakres 5) (zakres 100 105)))
[0, 100, 1, 101, 2, 102, 3, 103, 4, 104]

=> (lista (przeplatanie (zakres 1000000) „abc”))
[0, 'a', 1, 'b', 2, 'c']

wstawić
Nowość w wersji 0.10.1.

Stosowanie: (wstawić pozycja nast.)

Zwraca iterowalną liczbę elementów sekwencji oddzielonych elementem.

=> (lista (wstawka „!” „abcd”))
['a', '!', 'b', '!', 'c', '!', 'd']

=> (lista (wstawka -1 (zakres 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

iterowalne?
Stosowanie: (iterowalny? x)

Returns Prawdziwy if x jest iterowalny. Obiekty iterowalne zwracają nowy iterator kiedy (iter x) is
zwany. Kontrastować z iterator?.

=> ;; działa na stringi
=> (iterowalny? (str "abcde"))
Prawdziwy

=> ;; działa dla list
=> (iterowalny? [1 2 3 4 5])
Prawdziwy

=> ;; działa dla krotek
=> (iterowalny? (, 1 2 3))
Prawdziwy

=> ;; działa dla dyktatorów
=> (iterowalny? {:a 1:b 2:c 3})
Prawdziwy

=> ;; działa dla iteratorów/generatorów
=> (iterowalny? (powtórz 3))
Prawdziwy

iterator?
Stosowanie: (iterator? x)

Returns Prawdziwy if x jest iteratorem. Iteratory to obiekty, które zwracają się jako
iterator kiedy (iter x) jest nazywany. Kontrastować z iterowalne?.

=> ;; nie działa w przypadku listy
=> (iterator? [1 2 3 4 5])
Fałszywy

=> ;; ale możemy uzyskać iter z listy
=> (iterator? (iter [1 2 3 4 5]))
Prawdziwy

=> ;; nie działa dla dict
=> (iterator? {:a 1:b 2:c 3})
Fałszywy

=> ;; utwórz iterator z dyktatu
=> (iterator? (iter {:a 1 :b 2 :c 3}))
Prawdziwy

lista*
Stosowanie: (lista* głowa &odpoczynek ogon)

Generuje łańcuch zagnieżdżonych komórek wad (lista kropkowana) zawierających argumenty. Jeśli
lista argumentów ma tylko jeden element, zwróć go.

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

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

=> (lista* 1)
1

=> (wady? (lista* 1 2 3 4))
Prawdziwy

makrorozwinięcie
Nowość w wersji 0.10.0.

Stosowanie: (makrorozwiń Formularz)

Zwraca pełne rozwinięcie makra Nasz formularz.

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

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

makrorozwiń-1
Nowość w wersji 0.10.0.

Stosowanie: (makrorozwinięcie-1 Formularz)

Zwraca jednoetapowe rozwinięcie makra Nasz formularz.

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

połączyć z
Nowość w wersji 0.10.1.

Stosowanie: (połączyć z f &odpoczynek mapy)

Zwraca mapę składającą się z pozostałych map połączonych jako pierwsze. Jeśli klucz pojawi się w
więcej niż jedną mapę, mapowania z tej ostatniej (od lewej do prawej) zostaną połączone
mapowanie w wyniku poprzez wywołanie (f wynik-val val-in-ostatnie).

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

neg?
Stosowanie: (negatywne? x)

Returns Prawdziwy if x jest mniejsza od zera. Podnosi Wpisz błąd if (nie jesteś (numeryczne? X)).

=> (ujemny? -2)
Prawdziwy

=> (ujemne? 3)
Fałszywy

=> (ujemne? 0)
Fałszywy

zero?
Stosowanie: (zero? x)

Returns Prawdziwy if x is zero / żaden.

=> (zero? zero)
Prawdziwy

=> (zero? Brak)
Prawdziwy

=> (zero? 0)
Fałszywy

=> (setf x zero)
=> (zero? x)
Prawdziwy

=> ;; list.append zawsze zwraca Brak
=> (zero? (.append [1 2 3] 4))
Prawdziwy

Żaden?
Stosowanie: (nic? x)

Returns Prawdziwy if x is żaden.

=> (brak? Brak)
Prawdziwy

=> (brak? 0)
Fałszywy

=> (setf x Brak)
=> (żaden? x)
Prawdziwy

=> ;; list.append zawsze zwraca Brak
=> (brak? (.append [1 2 3] 4))
Prawdziwy

n-ty
Stosowanie: (nr pot n &opcjonalny [domyślny zero])

Zwraca n-ty element w kolekcji, licząc od 0. Zwraca wartość domyślną, zeroJeśli
poza granicami (o ile nie określono inaczej). Podnosi Błąd wartości if n jest ujemny.

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

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

=> (zero? (n-te [1 2 4 7] 5))
Prawdziwy

=> (n-te [1 2 4 7] 5 „domyślne”)
'domyślny'

=> (n-ty (weź 3 (upuść 2 [1 2 3 4 5 6])) 2))
5

=> (n-ty [1 2 4 7] -1)
Traceback (ostatnie połączenie ostatnio):
...
Błąd wartości: Indeksy dla islice() muszą mieć wartość Brak lub liczbę całkowitą: 0 <= x <= sys.maxsize.

numeryczny?
Stosowanie: (numeryczne? x)

Returns Prawdziwy if x jest liczbą, zgodnie z definicją w Pythonie liczby.Numer class.

=> (numeryczny? -2)
Prawdziwy

=> (numeryczny? 3.2)
Prawdziwy

=> (numeryczny? „foo”)
Fałszywy

dziwne?
Stosowanie: (dziwne? x)

Returns Prawdziwy if x to jest dziwne. Podnosi Wpisz błąd if (nie jesteś (numeryczne? X)).

=> (nieparzyste? 13)
Prawdziwy

=> (nieparzyste? 2)
Fałszywy

=> (nieparzyste? 0)
Fałszywy

pozycja?
Stosowanie: (poz? x)

Returns Prawdziwy if x jest większa od zera. Podnosi Wpisz błąd if (nie jesteś (numeryczne? X)).

=> (poz? 3)
Prawdziwy

=> (poz? -2)
Fałszywy

=> (poz? 0)
Fałszywy

Dopiero
Stosowanie: (druga kol.)

Zwraca drugi element członkowski pot. Równoważny (otrzymać pot 1).

=> (sekunda [0 1 2])
1

kilka
Nowość w wersji 0.10.0.

Stosowanie: (trochę pred kol.)

Zwraca pierwszą logicznie prawdziwą wartość (przed x) dla każdego x in pot, W przeciwnym razie zero.
Powrót zero if pot jest pusty.

=> (niektóre nawet? [2 4 6])
Prawdziwy

=> (zero? (nawet niektórzy? [1 3 5]))
Prawdziwy

=> (zero? (jakaś tożsamość [0 "" []]))
Prawdziwy

=> (pewna tożsamość [0 "niepusty ciąg" []])
„niepusty ciąg”

=> (zero? (niektóre nawet? []))
Prawdziwy

strunowy?
Stosowanie: (strunowy? x)

Returns Prawdziwy if x jest ciągiem.

=> (string? „foo”)
Prawdziwy

=> (ciąg? -2)
Fałszywy

symbol?
Stosowanie: (symbol? x)

Returns Prawdziwy if x jest symbolem.

=> (symbol? 'foo)
Prawdziwy

=> (symbol? '[abc])
Fałszywy

zero?
Stosowanie: (zero? x)

Returns Prawdziwy if x wynosi zero.

=> (zero? 3)
Fałszywy

=> (zero? -2)
Fałszywy

=> (zero? 0)
Prawdziwy

Sekwencja Funkcje
Funkcje sekwencji mogą tworzyć potencjalnie nieskończoną sekwencję lub działać na niej bez
wymaganie, aby sekwencja była w pełni zrealizowana na liście lub podobnym kontenerze. Robią to poprzez
zwrócenie iteratora Pythona.

Jako przykład użycia możemy użyć kanonicznego nieskończonego generatora liczb Fibonacciego
niektóre z tych funkcji.

(definicja fib []
(ustaw na 0)
(setv b 1)
(choć to prawda
(wydajność a)
(setv (, ab) (, b (+ ab)))))

Zanotuj (dopóki prawdziwy ...) pętla. Jeśli uruchomimy to w REPL,

=> (fikcja)


Wywołanie funkcji zwraca jedynie iterator, ale nie działa, dopóki go nie zużyjemy.
Próbowanie czegoś takiego nie jest zalecane, ponieważ nieskończona pętla będzie działać aż do tego
zużywa całą dostępną pamięć RAM, lub w tym przypadku, dopóki jej nie zabiję.

=> (lista (fib))
[1] 91474 zabitych hy

Aby uzyskać pierwsze 10 liczb Fibonacciego, użyj wziąć, Należy pamiętać, że wziąć zwraca również generator,
więc tworzę z tego listę.

=> (lista (weź 10 (fib)))
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Aby uzyskać liczbę Fibonacciego pod indeksem 9 (zaczynając od 0):

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

cykl
Stosowanie: (cykl kol.)

Zwraca nieskończony iterator elementów zbioru.

=> (lista (weź 7 (cykl [1 2 3])))
[1, 2, 3, 1, 2, 3, 1]

=> (lista (weź 2 (cykl [1 2 3])))
[1, 2]

odrębny
Stosowanie: (odrębny kol.)

Zwraca iterator zawierający tylko unikalne elementy członkowskie pot.

=> (lista (odrębny [ 1 2 3 4 3 5 2 ]))
[1, 2, 3, 4, 5]

=> (lista (odrębne []))
[]

=> (lista (odrębna (iter [ 1 2 3 4 3 5 2 ])))
[1, 2, 3, 4, 5]

upuszczać
Stosowanie: (upuszczać n kol.)

Zwraca iterator, pomijając pierwszy n członkowie pot. Podnosi Błąd wartości if n is
negatywny.

=> (lista (upuść 2 [1 2 3 4 5]))
[3, 4, 5]

=> (lista (upuść 4 [1 2 3 4 5]))
[5]

=> (lista (upuść 0 [1 2 3 4 5]))
[1, 2, 3, 4, 5]

=> (lista (upuść 6 [1 2 3 4 5]))
[]

ostatni
Stosowanie: (ostatni n kol.)

Zwraca iterator wszystkich elementów oprócz ostatniego n przedmioty w pot. Podnosi Błąd wartości if n is
negatywny.

=> (lista (upuść ostatnie 5 (zakres 10 20)))
[10, 11, 12, 13, 14]

=> (lista (upuść ostatnie 0 (zakres 5)))
[0, 1, 2, 3, 4]

=> (lista (upuść ostatnie 100 (zakres 100)))
[]

=> (importuj narzędzia itertools)
=> (lista (weź 5 (upuść ostatnie 100 (itertools.count 10))))
[10, 11, 12, 13, 14]

upuść na chwilę
Stosowanie: (upuść na chwilę pred kol.)

Zwraca iterator, pomijając elementy członkowskie pot aż do pred is Fałszywy.

=> (lista (upuść podczas parzystego? [2 4 7 8 9]))
[7, 8, 9]

=> (lista (upuszczana liczba numeryczna? [1 2 3 Brak „a”])))
[Żadne, ty]

=> (lista (upuść podczas pozycji? [2 4 7 8 9]))
[]

filtrować
Stosowanie: (filtr pred kol.)

Zwraca iterator dla wszystkich elementów w pot które przekazują orzeczenie pred.

Zobacz też usunąć.

=> (lista (pozycja filtra? [1 2 3 -4 5 -7]))
[1, 2, 3, 5]

=> (lista (filtr parzysty? [1 2 3 -4 5 -7]))
[2, -4]

spłaszczyć
Nowość w wersji 0.9.12.

Stosowanie: (spłaszczyć kol.)

Zwraca pojedynczą listę wszystkich elementów w pot, spłaszczając wszystkie zawarte listy i/lub
krotki.

=> (spłaszcz [1 2 [3 4] 5])
[1, 2, 3, 4, 5]

=> (spłaszcz ["foo" (, 1 2) [1 [2 3] 4] "pasek"])
['foo', 1, 2, 1, 2, 3, 4, 'pasek']

powtarzać
Stosowanie: (brzmieć fn x)

Zwraca iterator x, fn(x), fn(fn(x)), itp.

=> (lista (weź 5 (iteruj, dodaj 5)))
[5, 6, 7, 8, 9]

=> (lista (weź 5 (iteruj (fn [x] (* xx)) 5)))
[5, 25, 625, 390625, 152587890625]

czytać
Stosowanie: (czytać &opcjonalny [z pliku euf])

Czyta następne wyrażenie Hy z z pliku (domyślnie sys.stdin) i może przyjąć
pojedynczy bajt jako EOF (domyślnie jest to pusty ciąg). Podnosi EOFEBłąd if z pliku kończy się wcześniej
można przeanalizować pełne wyrażenie.

=> (czytaj)
(+ 2 2)
(„+” 2 2)
=> (eval (czytaj))
(+ 2 2)
4

=> (importuj io)
=> (bufor def (io.StringIO "(+ 2 2)\n(- 2 1)"))
=> (eval (zastosuj odczyt [] {bufor „z_pliku”}))
4
=> (eval (zastosuj odczyt [] {bufor „z_pliku”}))
1

=> ; zakładając, że „example.hy” zawiera:
=> ; (wydrukuj „cześć”)
=> ; (wypisz „przyjaciele!”)
=> (z [[f (otwarte "example.hy")]]
... (próbować
... (choć to prawda
... (niech [[exp (czytaj f)]]
... (Do
... (wydrukuj „OHY” exp)
... (ocena exp))))
... (złap [e EOFError]
... (wydrukuj „EOF!”))))
OHY („drukuj”, „cześć”)
cześć
OHY („drukuj” „przyjaciele!”)
przyjaciele!
EOF!

usunąć
Stosowanie: (usunąć pred kol.)

Zwraca iterator z pot z elementami, które przekazują predykat, pred, REMOVED.

Zobacz też filtrować.

=> (lista (usunąć nieparzyste? [1 2 3 4 5 6 7]))
[2, 4, 6]

=> (lista (usunąć pozycję? [1 2 3 4 5 6 7]))
[]

=> (lista (usunąć neg? [1 2 3 4 5 6 7]))
[1, 2, 3, 4, 5, 6, 7]

powtarzać
Stosowanie: (powtarzać x)

Zwraca iterator (nieskończony). x.

=> (lista (weź 6 (powtórz „s”)))
[ty, ty, ty, ty, ty, ty, ty]

wielokrotnie
Stosowanie: (wielokrotnie fn)

Zwraca iterator poprzez wywołanie fn Wielokrotnie.

=> (importuj [random [randint]])

=> (lista (weź 5 (wielokrotnie (fn [] (randint 0 10)))))
[6, 2, 0, 6, 7]

wziąć
Stosowanie: (brać n kol.)

Zwraca iterator zawierający pierwszy n członkowie pot. Podnosi Błąd wartości if n is
negatywny.

=> (lista (weź 3 [1 2 3 4 5]))
[1, 2, 3]

=> (lista (weź 4 (powtórz „s”)))
[ty, ty, ty, ty]

=> (lista (weź 0 (powtórz „s”)))
[]

weź-n
Stosowanie: (weź-n-te n kol.)

Zwraca iterator zawierający Every n-ty członek pot.

=> (lista (weź-n-te 2 [1 2 3 4 5 6 7]))
[1, 3, 5, 7]

=> (lista (weź-n-te 3 [1 2 3 4 5 6 7]))
[1, 4, 7]

=> (lista (weź-n-te 4 [1 2 3 4 5 6 7]))
[1, 5]

=> (lista (weź-n-te 10 [1 2 3 4 5 6 7]))
[1]

na chwilę
Stosowanie: (na chwilę pred kol.)

Zwraca iterator z pot tak długo jak pred powraca Prawdziwy.

=> (lista (pozycja do wzięcia na chwilę? [ 1 2 3 -4 5]))
[1, 2, 3]

=> (lista (podczas negacji? [ -4 -3 1 2 5]))
[-4, -3]

=> (lista (weź na chwilę negację? [ 1 2 3 -4 5]))
[]

zamek błyskawiczny
Nowość w wersji 0.9.13.

Stosowanie: (zap fn pot ...)

Równoważny zamek błyskawiczny, ale używa funkcji wieloargumentowej zamiast tworzyć krotkę. Jeśli
zamek błyskawiczny jest wówczas wywoływana z N zbiorami fn musi przyjąć N argumentów.

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

Czytelnik Makra
Makra czytnika dają Lispowi możliwość modyfikowania i zmiany składni w locie. Nie chcesz
Notacja polska? Makro czytnika może z łatwością to zrobić. Chcesz mieć sposób Clojure'a
wyrażenie regularne? Makra czytnika również mogą to łatwo zrobić.

Składnia
=> (defreader ^ [wyraż] (wydrukuj wyrażenie))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Witam"
"Cześć"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

Hy nie ma dosłownego określenia krotek. Powiedzmy, że nie lubisz (, ...) i chcieć czegoś innego. Ten
to problem, który czytniki makr potrafią w zgrabny sposób rozwiązać.

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

Możesz nawet zrobić to jak Clojure i mieć literał dla wyrażeń regularnych!

=> (importuj ponownie)
=> (defreader r [expr] `(re.compile ~expr))
=> #r.*”
Obiekt <_sre.SRE_Pattern pod adresem 0xcv7713ph15#>

Realizacja
defreader przyjmuje pojedynczy znak jako nazwę symbolu makra czytnika; cokolwiek dłużej
zwróci błąd. Wdrożeniowo, defreader rozszerza się do lambdy pokrytej a
dekorator. Ten dekorator zapisuje lambdę w słowniku z nazwą modułu i
symbol.

=> (defreader ^ [wyraż] (wydrukuj wyrażenie))
;=> (with_decorator (hy.macros.reader ^) (fn [wyrażenie] (drukowanie wyrażenie)))

# rozszerza się do (dispatch_reader_macro ...) do którego przekazywany jest symbol i wyrażenie
prawidłową funkcję.

=> #^()
;=> (dispatch_reader_macro ^ ())
=> #^"Witam"
"Cześć"

UWAGA:
Ze względu na ograniczenia leksera i parsera Hy, makra czytnika nie mogą przedefiniować zdefiniowanych
składnia taka jak ()[]{}. Najprawdopodobniej zostanie to rozwiązane w przyszłości.

Wewnętrzne Hy Dokumenty
UWAGA:
Te bity są głównie przydatne dla ludzi, którzy hakują sam Hy, ale można je również wykorzystać
tych, którzy zagłębiają się w programowanie makr.

Hy modele
Wprowadzenie do Hy modele
Modele Hy to bardzo cienka warstwa na zwykłych obiektach Pythona, reprezentująca źródło Hy
kod jako dane. Modele dodają jedynie informacje o pozycji źródła i kilka metod
wspierają czystą manipulację kodem źródłowym Hy, na przykład w makrach. Aby to osiągnąć
cel, modele Hy są połączeniem podstawowej klasy Pythona i HyObiekt.

HyObiekt
hy.models.HyObiekt jest klasą bazową modeli Hy. Implementuje tylko jedną metodę, obsługi produkcji rolnej, która zastąpiła,
który zastępuje pozycję źródłową bieżącego obiektu tą przekazaną jako argument.
Dzięki temu możemy śledzić pierwotną pozycję wyrażeń, które zostały zmodyfikowane przez
makra, czy to w kompilatorze, czy w czystych makrach hy.

HyObiekt nie jest przeznaczony do bezpośredniego użycia do tworzenia modeli Hy, ale jedynie jako miks
dla innych zajęć.

Mieszanka modele
Listy ujęte w nawiasy i nawiasy są analizowane jako modele złożone przez parser Hy.

HyList
hy.models.list.HyList jest klasą bazową „iterowalnych” modeli Hy. Jego podstawowym zastosowaniem jest
reprezentują w nawiasach [] listy, które użyte jako wyrażenie najwyższego poziomu przekładają się na
Literały listy Pythona w fazie kompilacji.

Dodanie HyList do innego iterowalnego obiektu ponownie wykorzystuje klasę obiektu po lewej stronie,
przydatne zachowanie, na przykład gdy chcesz połączyć obiekty Hy w makrze.

HyExpression
hy.models.expression.HyExpression dziedziczy HyList dla nawiasów () wyrażenia. The
Wynik kompilacji tych wyrażeń zależy od pierwszego elementu listy: the
kompilator wysyła wyrażenia pomiędzy specjalnymi formularzami kompilatora, makrami zdefiniowanymi przez użytkownika i
regularne wywołania funkcji Pythona.

HyDict
hy.modele.dict.HyDict dziedziczy HyList dla nawiasów klamrowych {} wyrażenia, które się kompilują
aż do literału słownikowego Pythona.

Decyzja o użyciu listy zamiast dyktatu jako klasy bazowej dla HyDict pozwala łatwiej
manipulowanie słownikami w makrach, z dodatkową korzyścią polegającą na umożliwieniu wyrażeń złożonych
jako klawisze dyktowania (jak na przykład HyExpression Klasy Pythona nie można hashować).

Atomowy modele
W strumieniu wejściowym ciągi znaków są umieszczane w cudzysłowie, zgodnie z notacją Pythona dla ciągów,
są analizowane jako pojedynczy token, który jest bezpośrednio analizowany jako HyString.

Nieprzerwany ciąg znaków, z wyłączeniem spacji, nawiasów, cudzysłowów i podwójnych cudzysłowów
i komentarze są analizowane jako identyfikator.

Identyfikatory są przekształcane w modele atomowe podczas fazy analizowania w następującej kolejności:

· HyInteger

· HyFloat

· HyKompleks (jeśli atom nie jest nagi j)

· HySłowo kluczowe (jeśli atom zaczyna się od :)

· HySymbol

HyString
hy.models.string.HyString jest klasą bazową modeli Hy odpowiadających łańcuchom. To także
reprezentuje literały łańcuchowe w cudzysłowie, "", które kompilują się do ciągu Unicode
literały w Pythonie. HyStringi dziedziczą obiekty Unicode w Pythonie 2, a obiekty string w
Python 3 (i dlatego nie są zależne od kodowania).

HyString modele oparte są niezmienne.

Ciągi literałów Hy mogą rozciągać się na wiele linii i są traktowane przez analizator składni jako pojedyncze
unit, z poszanowaniem znaków ucieczki Pythona dla ciągów Unicode.

Numeryczne modele
hy.models.integer.HyInteger reprezentuje literały całkowite (przy użyciu długie wpisz w Pythonie 2,
i int w Pythonie 3).

hy.models.float.HyFloat reprezentuje literały zmiennoprzecinkowe.

hy.models.complex.HyComplex reprezentuje literały złożone.

Modele numeryczne są analizowane przy użyciu odpowiedniej procedury Pythona i prawidłowego języka Python
literały zostaną zamienione na ich odpowiednik Hy.

HySymbol
hy.modele.symbol.HySymbol to model używany do reprezentowania symboli w języku Hy. To
dziedziczy HyString.

HySymbol obiekty są zniekształcane w fazie analizowania, aby pomóc w interoperacyjności Pythona:

· Symbole otoczone gwiazdkami (*) są zamieniane na wielkie litery;

· Kreski (-) są zamieniane na podkreślenia (_);

· Jeden końcowy znak zapytania (?) zamienia się w wiodący Jest_.

Zastrzeżenie: ponieważ zniekształcanie odbywa się w fazie analizowania, jest to możliwe
programowo generuj symbole HySymbol, których nie można wygenerować za pomocą kodu źródłowego Hy. Takie
mechanizm jest używany przez gensym do generowania „nieinternowanych” symboli.

HySłowo kluczowe
hy.modele.słowo kluczowe.Hysłowo kluczowe reprezentuje słowa kluczowe w Hy. Słowa kluczowe to symbole zaczynające się od
a :. Klasa dziedziczy HyString.

Aby odróżnić HySłowa kluczowe od HySymbole, bez możliwości (mimowolnego)
kolizje, znak Unicode do użytku prywatnego „\uFDD0” jest dołączany do słowa kluczowego literał
przed przechowywaniem.

Wady Komórki
hy.models.cons.hycons jest reprezentacją przyjazną dla Pythona minusy komórki. Wady komórek są
szczególnie przydatne do naśladowania cech „zwykłych” wariantów LISP-a, takich jak Scheme lub Common
Seplenienie.

Komórka wad to obiekt składający się z 2 elementów, zawierający a wózek (głowa) i a CDR (ogon). W jakimś Lisp
wariantach, komórka wad jest podstawowym elementem składowym, a w rzeczywistości są to wyrażenia S
reprezentowane jako połączone listy komórek wad. W Hy nie jest tak jak zwykle
wyrażenia składają się z list Pythona zawiniętych w a HyExpression. Jednakże HyCony
naśladuje w ten sposób zachowanie „zwykłych” wariantów Lispa:

· (Cons coś zero) is (HyWyrażenie [coś])

· (Cons coś jakaś lista) is ((typ jakaś lista) (+ [coś] jakaś lista)) (gdyby
jakaś lista dziedziczy z podstęp).

· (otrzymać (Cons a b) 0) is a

· (plasterek (Cons a b) 1) is b

Hy obsługuje składnię listy kropkowanej, gdzie '(A . b) znaczy (Cons 'a 'B) i '(A b . c) znaczy
(Cons 'a (Cons 'b 'C)). Jeśli kompilator napotka komórkę wad na najwyższym poziomie, podnosi
błąd kompilacji.

HyCony otacza przekazane argumenty (samochód i cdr) typami Hy, aby ułatwić manipulację
wady komórek w kontekście makra.

Hy Wewnętrzne Teoria
Przegląd
Elementy wewnętrzne Hy działają jako nakładka na kod bajtowy Pythona, dzięki czemu sam Hy
kompiluje się do kodu bajtowego Pythona, umożliwiając niezmodyfikowanemu środowisku wykonawczemu Pythona uruchomienie kodu Hy,
nawet tego nie zauważając.

Robimy to poprzez tłumaczenie Hy na wewnętrzną strukturę danych Pythona AST i
budowanie tego AST w kodzie bajtowym Pythona przy użyciu modułów ze standardu Python
biblioteka, abyśmy nie musieli duplikować całej pracy elementów wewnętrznych Pythona dla każdego
pojedyncza wersja Pythona.

Hy działa w czterech etapach. Poniższe sekcje omówią każdy etap Hy od źródła do
czas wykonywania.

Cel 1 i 2: Tokenizowanie i Rozbiór gramatyczny zdania
Pierwszym etapem kompilacji Hy jest przekształcenie źródła w tokeny, z którymi możemy sobie poradzić. My
użyj projektu o nazwie rply, który jest naprawdę ładnym (i szybkim) parserem, napisanym w podzbiorze
Pythona o nazwie rpython.

Cały kod leksykalny jest zdefiniowany w hy.lex.lexer. Ten kod głównie definiuje Hy
gramatykę, a wszystkimi trudniejszymi częściami zajmuje się rply — po prostu definiujemy
„oddzwonienia” dla odpowiedzi hy.lex.parser, który pobiera wygenerowane tokeny i zwraca
Hy modele.

Możesz myśleć o modelach Hy jako o „AST” dla Hy, na tym działają Macros
(bezpośrednio) i tego właśnie używa kompilator podczas kompilowania Hy.

ZOBACZ TAKŻE:
Sekcja Hy modele aby uzyskać więcej informacji na temat modeli Hy i ich znaczenia.

Ewolucja krok po kroku 3: Hy Kompilacja do Python AST
To tutaj dzieje się najwięcej magii w Hy. To tutaj zabieramy Hy AST (modelki),
i skompiluj je do Pythona AST. Dzieje się tu kilka fajnych rzeczy, które wykraczają poza kilka
problemów w AST, a praca w kompilatorze jest jedną z najważniejszych prac, jakie wykonujemy
mają.

Kompilator jest nieco skomplikowany, więc nie czuj się źle, jeśli nie zachwiejesz się nim za pierwszym razem,
naprawienie tego może zająć trochę czasu.

Głównym punktem wejścia do kompilatora jest HyASTCompiler.compile. Ta metoda jest wywoływana i
jedyną prawdziwą „publiczną” metodą w tej klasie (to znaczy, że tak naprawdę nie obiecujemy, że
API poza tą metodą).

Tak naprawdę, nawet wewnętrznie, prawie nigdy nie wracamy bezpośrednio, prawie zawsze na siłę
przez drzewo Hy skompilowaći często będzie to robić z elementami podrzędnymi wyrażenia
że mamy. Prawidłowe wysyłanie elementów podrzędnych zależy od dyspozytora opartego na typach.

Wszystkie metody wykonujące kompilację są oznaczone znakiem @konstrukcje() dekorator. Możesz
albo przekaż klasę kompilowanego modelu Hy, albo możesz użyć łańcucha znaków
wyrażenia. Wyjaśnię to za chwilę.

i terminów, a STAGE Typ-wysyłka
Zacznijmy w skompilować metoda. Pierwszą rzeczą, którą robimy, jest sprawdzenie typu rzeczy
budujemy. Sprawdzamy, czy mamy metodę, która może zbudować plik rodzaj() że my
mieć i wysłać do metody, która może sobie z tym poradzić. Jeśli nie mamy żadnych metod, które by to umożliwiały
zbuduj ten typ, podnosimy plik wewnętrzny Wyjątek.

Na przykład, jeśli mamy HyString, mamy mapowanie Hy AST prawie 1 do 1 na Python
AST. The kompilacja_string metoda przyjmuje HyStringi zwraca ast.Str()
wypełnione prawidłowymi numerami wierszy i treścią.

Makro-Rozwiń
Jeśli otrzymamy A HyExpression, spróbujemy sprawdzić, czy jest to znane makro, i naciśniemy, aby je mieć
rozwinął się poprzez wywołanie hy.macros.macroexpand, a następnie wepchnij wynik z powrotem do
HyASTCompiler.compile.

druga STAGE Przesyłanie wyrażeń
Jedynym szczególnym przypadkiem jest HyExpression, ponieważ musimy utworzyć różne AST w zależności
na danym specjalnym formularzu. Na przykład, kiedy trafimy na (gdyby prawdziwy prawdziwy fałszywe), mamy
trzeba wygenerować a ast.Ifi poprawnie skompiluj podwęzły. To tutaj @konstrukcje()
z ciągiem jako argumentem.

Dla wyrażenie_kompilacji (który jest zdefiniowany za pomocą @builds(HyExpression)) wyślę
na podstawie ciągu pierwszego argumentu. Jeśli z jakiegoś powodu pierwszy argument nie jest
string, poprawnie obsłuży również ten przypadek (najprawdopodobniej podnosząc an Wyjątek).

Jeśli ciąg nie jest znany Hy, domyślnie utworzy plik ast.Zadzwoń, który spróbuje
wykonaj wywołanie w czasie wykonywania (w Pythonie, coś w stylu bla()).

Zagadnienia Dobranie (Hit) w Python AST
Python AST jest świetny; to właśnie umożliwiło nam napisanie tak potężnego projektu
Python bez konieczności zbyt ostrej walki z Pythonem. Jak wszystko, mieliśmy już swój udział
problemów, a oto krótka lista typowych, na które możesz się natknąć.

Python różnicuje pomiędzy Oświadczenia i Expressions.

Może to nie brzmieć jak wielka sprawa — w rzeczywistości dla większości programistów Pythona tak będzie
wkrótce stanie się momentem „No cóż, tak”.

W Pythonie, robiąc coś takiego:

dla x in zasięg(10): przechodzić, Ponieważ drukuje wyrażenia i dla nie jest
wyrażenie, jest to instrukcja przepływu sterowania. Rzeczy jak 1 + 1 są wyrażeniami, takimi jakie są lambda
x: 1 + x, ale inne funkcje językowe, takie jak if, dlalub Podczas są stwierdzenia.

Ponieważ nie mają one „wartości” dla Pythona, sprawia to, że praca w Hy jest trudna, ponieważ coś robisz
lubić (wydrukować (gdyby prawdziwy prawdziwy FAŁSZ)) nie jest po prostu powszechne, jest oczekiwane.

W rezultacie automatycznie zmieniamy rzeczy za pomocą a Wynik obiekt, w którym oferujemy dowolne ast.stmt
które trzeba uruchomić, i pojedynczy ast.wyr które można wykorzystać do uzyskania dowolnej wartości
właśnie biegł. Hy robi to, wymuszając przypisanie do rzeczy podczas działania.

Na przykład Hy:

(wydrukuj (jeśli prawda prawda fałsz))

Zamieni się w:

Jeśli prawda:
_mangled_name_here = Prawda
jeszcze:
_mangled_name_here = Fałsz

wydrukuj _zniekształconą_nazwę_tutaj

OK, to było trochę kłamstwo, ponieważ faktycznie zamieniamy to stwierdzenie na:

wydrukuj Prawda, jeśli Prawda, w przeciwnym wypadku Fałsz

Zmuszając rzeczy do ast.wyr jeśli możemy, ale ogólna idea pozostaje aktualna.

Ewolucja krok po kroku 4: Python Kod bajtowy Wydajność i Czas pracy
Gdy mamy już gotowe drzewo AST języka Python, możemy spróbować skompilować je do języka Python
kod bajtowy, przepychając go eval. Odtąd nie mamy już kontroli i
Python zajmuje się wszystkim. Właśnie dlatego rzeczy takie jak śledzenie Pythona, pdb i
aplikacje Django działają.

Hy Makra
Korzystanie z gensym dla Bezpieczniej Makra
Pisząc makra, należy zachować ostrożność, aby uniknąć przechwytywania lub używania zmiennych zewnętrznych
nazwy zmiennych, które mogą powodować konflikt z kodem użytkownika.

Posłużymy się przykładowym makro nW (Patrz
http://letoverlambda.com/index.cl/guest/chap3.html#sek_5 aby uzyskać pełniejszy opis.)
nW to przykład, coś w rodzaju liczby if, gdzie na podstawie wyrażenia, jeden z
3 formy są wywoływane w zależności od tego, czy wyrażenie jest dodatnie, zerowe czy ujemne.

Pierwsze przejście może wyglądać następująco:

(defmacro nif [wyrażenie pos-forma-forma zerowa-forma-negatywna]
`(niech [[niejasna nazwa ~wyrażenie]]
(cond [(pos? niejasna nazwa) ~pos-form]
[(zero? niejasna nazwa) ~forma zerowa]
[(neg? niejasne-nazwa) ~forma-neg])))

gdzie niejasne imię jest próbą wybrania jakiejś nazwy zmiennej, aby nie kolidowała z inną
kod. Ale oczywiście, choć masz dobre intencje, nie jest to gwarancją.

Metoda gensym ma na celu wygenerowanie nowego, unikalnego symbolu właśnie na taką okazję.
Dużo lepsza wersja nW byłoby:

(defmacro nif [wyrażenie pos-forma-forma zerowa-forma-negatywna]
(niech [[g (gensym)]]
`(niech [[~g ~wyrażenie]]
(warunek [(pos? ~g) ~post-forma]
[(zero? ~g) ~forma zerowa]
[(neg? ~g) ~forma-neg]))))

Jest to łatwy przypadek, ponieważ istnieje tylko jeden symbol. Ale jeśli potrzeba kilku
gensym's istnieje drugie makro with-gensyms, które zasadniczo rozszerza się do serii niech
sprawozdania:

(z-gensymami [abc]
...)

rozwija się do:

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

więc nasz przepis napisany nW wyglądałby jak:

(defmacro nif [wyrażenie pos-forma-forma zerowa-forma-negatywna]
(z-gensymami [g]
`(niech [[~g ~wyrażenie]]
(warunek [(pos? ~g) ~post-forma]
[(zero? ~g) ~forma zerowa]
[(neg? ~g) ~forma-neg]))))

Wreszcie możemy stworzyć nowe makro, które zrobi to wszystko za nas. defmakro/g! zajmie
wszystkie symbole zaczynające się od g! i automatycznie zadzwoń gensym z resztą
symbol. Więc g!a stanie się (gensym "A").

Nasza ostateczna wersja nW, zbudowany z defmakro/g! staje się:

(defmacro/g! nif [wyrażenie pos-forma-forma zerowa-forma-ujemna]
`(niech [[~g!res ~wyrażenie]]
(cond [(pos? ~g!res) ~pos-form]
[(zero? ~g!res) ~forma zerowa]
[(neg? ~g!res) ~forma-neg]))))

Kontrola Macro Argumenty i Wychowywanie wyjątki
Hy kompilator Wbudowane

WSPÓŁPRACOWNIK MODUŁY INDEKS

Spis treści:

Anaforyczny Makra
Nowość w wersji 0.9.12.

Moduł makr anaforycznych sprawia, że ​​programowanie funkcjonalne w Hy jest bardzo zwięzłe i łatwe
czytać.
Makro anaforyczne to rodzaj makra programistycznego, które celowo przechwytuje jakąś formę
dostarczany do makra, do którego można się odwoływać za pomocą anafory (wyrażenie odnoszące się do
do innego). — Wikipedia (http://en.wikipedia.org/wiki/Anaphoric_macro)

Makra
ap-jeśli
Stosowanie: (ap-jeśli (bla) (wydrukować To))

Ocenia pierwszą formę pod kątem prawdziwości i wiąże ją z nią it zarówno w prawdzie, jak i w fałszu
gałęzie.

brzoskwinia
Stosowanie: (brzoskwinia [1 2 3 4 5] (wydrukować To))

Oceń formę każdego elementu na liście pod kątem skutków ubocznych.

ap-każdy-chwila
Stosowanie: (za każdym razem podstęp pred ciało)

Oceń formę dla każdego elementu, w którym zwracana jest forma predykatu Prawdziwy.

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

mapa aplikacji
Stosowanie: (ap-mapa Nasz formularz lista)

Anaforyczna forma mapy działa jak zwykła mapa, z tą różnicą, że zamiast funkcji
obiekt przyjmuje formę Hy. Specjalna nazwa it jest powiązany z bieżącym obiektem z
lista w iteracji.

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

ap-map-kiedy
Stosowanie: (ap-mapa-kiedy prefn rep lista)

Oceń mapowanie na liście, używając funkcji predykatu, aby określić, kiedy zastosować
forma.

=> (lista (ap-mapa-kiedy jest nieparzysta? (* it 2) [1 2 3 4]))
[2, 2, 6, 4]

=> (lista (ap-mapa-kiedy parzysta? (* it 2) [1 2 3 4]))
[1, 4, 3, 8]

filtr ap
Stosowanie: (filtr ap Nasz formularz lista)

Jak z mapa aplikacji zamiast funkcji przyjmujemy specjalną formę do filtrowania elementów
lista. Specjalna nazwa it jest powiązany z bieżącym elementem w iteracji.

=> (lista (filtr ap (> (* it 2) 6) [1 2 3 4 5]))
[4, 5]

ap-odrzuć
Stosowanie: (ap-odrzucić Nasz formularz lista)

Ta funkcja działa odwrotnie filtr ap, odrzuca elementy przechodzące przez
orzeczenie . Specjalna nazwa it jest powiązany z bieżącym elementem w iteracji.

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

ap-dotimes
Stosowanie (ap-dotimes n ciało)

Ta funkcja ocenia ciało n razy, ze specjalną zmienną it związany z 0 do
1-N. Jest to przydatne w przypadku skutków ubocznych.

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

ap-pierwszy
Stosowanie (ap-pierwszy prefn lista)

Ta funkcja zwraca pierwszy element, który przekazuje predykat lub żadenZ
zmienna specjalna it powiązany z bieżącym elementem w iteracji.

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

ap-ostatni
Stosowanie (ap-ostatni prefn lista)

Ta funkcja zwraca ostatni element, który przekazuje predykat lub żaden, ze specjalnym
zmienna it powiązany z bieżącym elementem w iteracji.

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

ap-redukcja
Stosowanie (ap-zmniejsz Nasz formularz podstęp &opcjonalny wartość początkowa)

Ta funkcja zwraca wynik zastosowania formy do pierwszych 2 elementów w treści i
zastosowanie wyniku i trzeciego elementu itd. aż do wyczerpania listy. Opcjonalnie
można podać wartość początkową, więc funkcja zostanie zastosowana do wartości początkowej i
zamiast tego pierwszy element. To ujawnia element, który jest iterowany jako it i prąd
skumulowana wartość jako acc.

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

pętla/powtarzanie
Nowość w wersji 0.10.0.

Połączenia pętla / powtarzać się makro zapewnia programistom prosty sposób korzystania z optymalizacji połączeń końcowych (TCO)
w swoim kodzie Hy.
Wywołanie ogona to wywołanie podprogramu, które ma miejsce w ramach innej procedury jako końcowe
działanie; może wygenerować wartość zwracaną, która jest następnie natychmiast zwracana przez wywołanie
procedura. Jeśli jest to wywołanie podprogramu, które może ostatecznie doprowadzić
do ponownego wywołania tego samego podprogramu w dół łańcucha wywołań, znajduje się w pozycji końcowej,
mówi się, że taki podprogram jest rekurencyjny, co jest szczególnym przypadkiem rekurencji.
Wywołania ogonowe są istotne, ponieważ można je zaimplementować bez dodawania nowego stosu
ramkę do stosu wywołań. Większość ram obecnej procedury nie jest potrzebna
więcej i można go zastąpić ramką wywołania ogonowego. Program może wówczas wykonać skok
do wywoływanego podprogramu. Tworzenie takiego kodu zamiast standardowej sekwencji wywołań jest
nazywana eliminacją ogona lub optymalizacją ogona. Pozwala na eliminację wezwań ogonowych
wywołania procedur w pozycji ogona mają być realizowane równie efektywnie jak instrukcje goto,
umożliwiając w ten sposób efektywne programowanie strukturalne. — Wikipedia (-
http://en.wikipedia.org/wiki/Tail_call)

Makra
pętla
pętla ustanawia punkt rekurencji. Z pętla, powtarzać się ponownie wiąże zmienne ustawione w pliku
punkt rekurencji i wysyła wykonanie kodu z powrotem do tego punktu rekurencji. Jeśli powtarzać się stosuje się
pozycja inna niż ogon, zgłaszany jest wyjątek.

Stosowanie: (pętla wiązania &odpoczynek ciało)

Przykład:

(wymagaj hy.contrib.loop)

(defn silnia [n]
(pętla [[w] [akt 1]]
(jeśli (zero? i)
acc
(powtórz (dec i) (* acc i)))))

(silnia 1000)

defmulti
Nowość w wersji 0.10.0.

defmulti pozwala przeciążyć funkcję o podaną liczbę argumentów i/lub kwargów.
Zainspirowany podejściem Clojure zdefiniuj.

=> (wymagaj hy.contrib.multi)
=> (domyślnie wiele zabaw
... ([a] „a”)
... ([ab] „ab”)
... ([abc] "abc"))
=> (zabawa 1)
"za"
=> (zabawa 1 2)
„ab”
=> (zabawa 1 2 3)
"ABC"

HACKING ON HY

Dołącz do rejestru ludzkiej, hej!
Proszę, przyjdź i zhakuj Hy!

Proszę, przyjdź i pobaw się z nami #hej on irc.freenode.net!

Proszę porozmawiać o tym na Twitterze z #hej hasztag!

Proszę o tym na blogu!

Proszę nie malować sprayem płotu sąsiada (bez grzecznego pytania)!

Włamać się!
Zrób to:

1. Stwórz faktyczny środowisko:

$ virtualenv venv

i aktywuj:

$ . venv/bin/aktywuj

albo użyj wirtualne środowisko aby stworzyć i zarządzać środowiskiem wirtualnym:

$ mkvirtualenv hy
$workon hy

2. Pobierz kod źródłowy:

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

lub użyj widelca:

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

3. Zainstaluj w celu włamania:

$cd hy/
$ pip instalacja -e .

4. Zainstaluj inne wymagania programistyczne:

$ pip install -r wymagania-dev.txt

5. Rób niesamowite rzeczy; spraw, by ktoś krzyknął z zachwytu/odrazy z powodu tego, czego dokonałeś.

Test!
Testy znajdują się w testy /. Używamy nos.

Aby uruchomić testy:

$ testy nosa

Napisz testy --- testy są dobre!

Warto także przeprowadzić testy na wszystkich obsługiwanych platformach i pod kątem zgodności z PEP 8
kod. Możesz to zrobić uruchamiając tox:

$ toksyczne

Dokument!
Dokumentacja znajduje się w dokumenty /. Używamy Sfinks.

Aby utworzyć dokumenty w formacie HTML:

$ Dokumentacja na płycie CD
$ utwórz HTML

Napisz dokumenty --- dokumenty są dobre! Nawet ten dokument!

Przyczyniając
Wpłaty są mile widziane i bardzo doceniane, każda drobnostka pomaga w tworzeniu Hy bardziej
niesamowite.

Żądania ściągnięcia są świetne! Kochamy ich; oto krótki przewodnik:

· Rozwiń repozytorium i utwórz gałąź tematyczną dla funkcji/poprawki. Unikaj bezpośredniego wprowadzania zmian
na gałęzi głównej.

· Wszystkim nowym funkcjom powinny towarzyszyć testy.

· Zanim wyślesz PR, przeprowadź testy i sprawdź swój kod pod kątem stylu
przewodnik. Możesz zrobić obie te rzeczy na raz:

$ zrobić d

· Dokonuj zatwierdzeń w jednostkach logicznych, aby łatwiej było je później śledzić i nawigować. Zanim
przesyłając PR, spróbuj zgnieść zatwierdzenia w zestawy zmian, do których łatwo będzie wrócić
później. Upewnij się także, że nie pozostawiłeś fałszywych białych znaków w zestawach zmian; Ten
pozwala uniknąć późniejszego tworzenia zatwierdzeń poprawek białych znaków.

· Jeśli chodzi o komunikaty zatwierdzające, staraj się przestrzegać następujących zasad:

· Spróbuj trzymać się limitu 50 znaków w pierwszym wierszu komunikatów zatwierdzeń Git.

· Aby uzyskać więcej szczegółów/wyjaśnień, należy dodać pustą linię i kontynuować
szczegółowo opisując zatwierdzenie.

· Na koniec dodaj siebie do pliku AUTORS (jako osobny commit): zasługujesz na to :)

· Wszystkie nadchodzące zmiany muszą zostać zatwierdzone przez 2 różnych członków głównego zespołu Hylang.
Dodatkowa recenzja jest mile widziana, ale na każdą z nich potrzebujemy co najmniej 2 podpisów
zmienić.

· Jeśli główny członek wysyła PR, znajdź 2 głównych członków, którzy nie obejmują
Zgłaszający PR. Chodzi o to, że jeden może współpracować z autorem PR, a drugi potwierdza
cały zestaw zmian.

· W przypadku dokumentacji i innych trywialnych zmian, dobrze jest połączyć się po jednym potwierdzeniu. Mamy
niski zasięg, więc byłoby wspaniale utrzymać tę barierę na niskim poziomie.

rdzeń Zespół zarządzający
Główny zespół programistów Hy składa się z następujących programistów:

· Juliański Danjou

· Morten Linderuda

· J Kenneth król

· Gergely Nagy

· Tuukka Turto

· Karen Zardzewiały

· Abhishek L

· Christopher Allan Webber

· Konrad Hinsena

· Będzie Kahna-Greene'a

· Paweł tagliamonte

· Nicolas Dandrimont

· Bob Tolberta

· Berker Peksag

· Clinton N. Dreisbacha

· han semaj

Korzystaj z hy online, korzystając z usług onworks.net