hy - Online in de cloud

PROGRAMMA:

NAAM

hy - hy Documentatie [afbeelding: Hy] [afbeelding]

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

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

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

Lijst hylang-bespreken

IRC #hy op Freenode

Bouw toestand
Travis CI.ONINDENT

Hy is een prachtig Lisp-dialect dat is ingebed in Python.

Sinds Hy zijn Lisp-code omzet in de Python Abstract Syntax Tree, heb je dat ook gedaan
de hele prachtige wereld van Python binnen handbereik, in Lisp-vorm!

Inhoud:

QUICK START

[afbeelding: Karen Rustard's knuffels] [afbeelding]

(Met dank aan Karen Rustad voor knuffels!)

HOE TO GET HY REAL SNELLE:

1. Maak een Virtueel Python Milieu.

2. Activeer uw virtuele Python-omgeving.

3. Installeren hy oppompen van PyPI Met pit installeren hy.

4. Start een REPL met hy.

5. Typ dingen in de REPL:

=> (print "Hy!")
Hy!
=> (defn salutationsnm [naam] (print (+ "Hy " naam "!")))
=> (aanhefnm "UwNaam")
Hy JouwNaam!

etc

6. Druk op CTRL-D als je klaar bent.

OMG! Dat is verbazingwekkend! I willen naar schrijven a Hy programma.

7. Open een elite programmeereditor en typ:

(print "Ik wilde coderen in de syntaxis van Python, maar toen kreeg ik Hy.")

8. Opslaan als geweldig.hy.

9. En voer uw eerste Hy-programma uit:

hy geweldig.hy

10.
Haal diep adem om niet te hyperventileren.

11.
Glimlach boosaardig en sluip naar je hydeaway en doe onuitsprekelijke dingen.

TUTORIAL

Welkom bij de Hy-tutorial!

In een notendop: Hy is een Lisp-dialect, maar wel een die de structuur ervan omzet in Python ...
letterlijk een conversie naar de abstracte syntaxisboom van Python! (Of om het nog ruwer te zeggen
termen, Hy is lisp-stick op een Python!)

Dit is best gaaf omdat het betekent dat Hy verschillende dingen is:

· Een Lisp die erg Pythonisch aanvoelt

· Voor Lispers: een geweldige manier om de gekke krachten van Lisp te gebruiken, maar dan in de wijde wereld van Python
bibliotheken (waarom ja, je kunt nu een Django-applicatie schrijven in Lisp!)

· Voor Pythonista's: een geweldige manier om Lisp te verkennen, vanuit het comfort van Python!

· Voor iedereen: een prettige taal met veel leuke ideeën!

Basic intro naar Lispelen For Pythonista's
Oké, misschien heb je Lisp nog nooit eerder gebruikt, maar wel Python!

Een "hello world"-programma in Hy is eigenlijk supereenvoudig. Laten we het proberen:

(print "Hallo wereld")

Zien? Eenvoudig! Zoals je misschien al geraden hebt, is dit hetzelfde als de Python-versie van:

afdrukken "Hallo wereld"

Om wat supereenvoudige wiskunde op te tellen, kunnen we het volgende doen:

(+1)

Dat zou 4 opleveren en het equivalent zijn van:

1 + 3

Wat je zult opvallen is dat het eerste item in de lijst de functie is die wordt aangeroepen en de
de rest van de argumenten zijn de argumenten die worden doorgegeven. Sterker nog, in Hy (zoals bij de meeste
Lisps) kunnen we meerdere argumenten doorgeven aan de plus-operator:

(+ 1 3 55)

Wat 59 zou opleveren.

Misschien heb je al eerder van Lisp gehoord, maar weet je er niet veel van. Lisp is niet zo moeilijk als jij
zou je kunnen denken, en Hy erft van Python, dus Hy is een geweldige manier om Lisp te leren.
Het belangrijkste dat duidelijk is aan Lisp, is dat er veel haakjes zijn. Dit kan
lijkt in eerste instantie verwarrend, maar het is niet zo moeilijk. Laten we eens kijken naar wat eenvoudige wiskunde
verpakt in een aantal haakjes die we in de Hy-interpreter konden invoeren:

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

Dit zou 38 opleveren. Maar waarom? Welnu, we zouden naar de equivalente uitdrukking kunnen kijken in
Python:

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

Als je zou proberen uit te vinden hoe het bovenstaande in Python zou werken, zou je dat natuurlijk doen
bereken de resultaten door elk binnenhaakje op te lossen. Dat is hetzelfde basisidee in
Hy. Laten we deze oefening eerst in Python proberen:

resultaat = ((1 + 3 + 88) / 2) - 8
# vereenvoudigd tot...
resultaat = (92 / 2) - 8
# vereenvoudigd tot...
resultaat = 46 - 8
# vereenvoudigd tot...
resultaat = 38

Laten we nu hetzelfde proberen in Hy:

(setv resultaat (- (/ (+ 1 3 88) 2) 8))
; vereenvoudigd tot...
(setv resultaat (- (/ 92 2) 8))
; vereenvoudigd tot...
(setv-resultaat (- 46 8))
; vereenvoudigd tot...
(setv-resultaat 38)

Zoals je waarschijnlijk al geraden had, is deze laatste uitdrukking met setv betekent het toewijzen van de variabele
"resultaat" naar 38.

Zien? Niet te hard!

Dit is het uitgangspunt van Lisp. Lisp staat voor "lijstverwerking"; dit betekent dat de
De structuur van het programma bestaat eigenlijk uit lijsten met lijsten. (Als je bekend bent met Python
lijsten, stel je dezelfde structuur voor als hierboven, maar in plaats daarvan met vierkante haken
je zult de bovenstaande structuur kunnen zien als zowel een programma als een datastructuur.) Dit is
gemakkelijker te begrijpen met meer voorbeelden, dus laten we een eenvoudig Python-programma schrijven, testen,
en toon dan het equivalente Hy-programma:

def simple_conversation():
print "Hallo! Ik wil je graag leren kennen. Vertel me iets over jezelf!"
naam = raw_input("Wat is je naam? ")
age = raw_input("Wat is je leeftijd?")
print "Hallo " + naam + "! Ik zie dat je " + leeftijd + " jaar oud bent."

eenvoudige_conversatie()

Als we dit programma zouden uitvoeren, zou het er als volgt uit kunnen zien:

Hallo! Ik wil je graag leren kennen. Vertel mij eens iets over jezelf!
Hoe heet je? Gary
Hoe oud ben jij? 38
Hallo Gary! Ik zie dat je 38 jaar oud bent.

Laten we nu eens kijken naar het equivalente Hy-programma:

(defn eenvoudige conversatie []
(print "Hallo! Ik wil je graag leren kennen. Vertel me iets over jezelf!")
(setv-naam (onbewerkte invoer "Wat is uw naam?"))
(setv leeftijd (onbewerkte invoer "Wat is je leeftijd?"))
(print (+ "Hallo " naam "! Ik zie dat je "
leeftijd "jaar oud.")))

(eenvoudig gesprek)

Als je naar het bovenstaande programma kijkt, zolang je maar onthoudt dat het eerste element in elk is
lijst van het programma is de functie (of macro... daar komen we later op terug) die wordt aangeroepen
en dat de rest de argumenten zijn, is het vrij eenvoudig om erachter te komen wat dit allemaal betekent.
(Zoals je waarschijnlijk ook al geraden had, def is de Hy-methode voor het definiëren van methoden.)

Toch vinden veel mensen dit in eerste instantie verwarrend omdat er zoveel haakjes zijn,
maar er zijn genoeg dingen die dit gemakkelijker kunnen maken: houd de inspringing mooi en
gebruik een editor met overeenkomst tussen haakjes (dit zal u helpen erachter te komen wat elk
haakjes passen bij) en de dingen zullen comfortabel gaan aanvoelen.

Er zijn enkele voordelen aan het hebben van een codestructuur die eigenlijk uit heel eenvoudige gegevens bestaat
structuur waarop de kern van Lisp is gebaseerd. In de eerste plaats betekent het dat uw programma's dat wel zijn
gemakkelijk te ontleden zijn en dat de gehele feitelijke structuur van het programma heel duidelijk zichtbaar wordt
aan jou. (Er is een extra stap in hy waarbij de structuur die je ziet wordt omgezet naar die van Python
eigen representaties ... in "zuiverdere" Lisp's zoals Common Lisp of Emacs Lisp, de data
structuur die je in de code ziet en de datastructuur die wordt uitgevoerd is veel meer
letterlijk dichtbij.)

Een andere implicatie hiervan zijn macro's: als de structuur van een programma uit eenvoudige gegevens bestaat
structuur, dat betekent dat je code kunt schrijven die heel gemakkelijk code kan schrijven, wat betekent dat
het implementeren van geheel nieuwe taalfuncties kan erg snel zijn. Vóór Hy was dit niet het geval
heel goed mogelijk voor Python-programmeurs ... nu kun jij ook gebruik maken van de ongelooflijke macro's
kracht (pas op dat u ze niet naar de voet richt)!

Hy is a Met lisp-smaak Python
Hy converteert naar Python's eigen abstracte syntaxisboom, dus je zult dat allemaal snel gaan vinden
de vertrouwde kracht van Python ligt binnen handbereik.

Je hebt volledige toegang tot de datatypen en standaardbibliotheek van Python in Hy. Laten we experimenteren
met dit in de hy-interpreter:

=> [1 2 3]
[1, 2, 3]
=> {"hond" "blaffen"
... "kat" "miauw"}
...
{'hond': 'blaffen', 'kat': 'miauw'}
=> (, 1 2 3)
(1, 2, 3)

Als u bekend bent met andere Lisps, is het wellicht interessant dat Hy de Common ondersteunt
Lisp-methode voor citeren:

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

Je hebt ook toegang tot alle leuke methoden van de ingebouwde typen:

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

Wat is dit? Ja inderdaad, dit is precies hetzelfde als:

" fooooo ".strip()

Dat klopt --- Lisp met puntnotatie! Als we deze string als variabele hebben toegewezen, kunnen we
kan ook het volgende doen:

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

Hoe zit het met voorwaardelijk?:

(als (iets proberen)
(print "dit is als het waar is")
(print "dit is indien onwaar"))

Zoals je hierboven kunt zien, is het eerste argument if is een waarheidstest, het tweede argument is dat wel
de body indien waar, en het derde argument (optioneel!) is indien onwaar (dwz. anders).

Als u complexere conditionele taken moet uitvoeren, zult u merken dat dit niet het geval is elif
verkrijgbaar in Hy. In plaats daarvan zou je iets moeten gebruiken dat cond. In Python zou je dat misschien wel kunnen doen
zoiets als:

ietsvar = 33
als iets > 50:
print "Die variabele is te groot!"
elif somevar < 10:
print "Die variabele is te klein!"
anders:
print "Die variabele klopt gewoon!"

In Hy zou je het volgende doen:

(cond
[(> ergens 50)
(print "Die variabele is te groot!")]
[(< ergens 10)
(print "Die variabele is te klein!")]
[WAAR
(print "Die variabele klopt gewoon!")])

Wat je zult merken is dat cond schakelt uit tussen een instructie die wordt uitgevoerd en
voorwaardelijk gecontroleerd op waar of onwaar, en vervolgens een stukje code dat moet worden uitgevoerd als het verandert
uit om waar te zijn. Je zult ook merken dat de anders wordt uiteindelijk eenvoudigweg geïmplementeerd door
controleren op waar -- dat is omdat waar zal altijd waar zijn, dus als we zo ver komen, zullen we dat ook doen
voer die altijd uit!

Je merkt misschien hierboven dat als je code hebt zoals:

(indien bepaalde voorwaarde
(lichaam-als-waar)
(body-indien-false))

Maar wacht! Wat als u meer dan één instructie wilt uitvoeren in de hoofdtekst van een van de
deze?

U kunt het volgende doen:

(als (iets proberen)
(doen
(print "dit is als het waar is")
(print "en waarom niet, laten we blijven praten over hoe waar het is!))
(print "deze is nog steeds gewoon vals"))

Je kunt zien dat we gebruikt hebben do om meerdere verklaringen in te pakken. Als u bekend bent met andere
Lisps, dit is het equivalent van prog ergens anders.

Opmerkingen beginnen met puntkomma's:

(print "dit wordt uitgevoerd")
; (druk af "maar dit zal niet gebeuren")
(+ 1 2 3) ; we voeren de toevoeging uit, maar niet deze opmerking!

Looping is niet moeilijk maar heeft een soort bijzondere structuur. In Python kunnen we het volgende doen:

want ik doe mee reeks(10):
print "'i' staat nu op " + str(i)

Het equivalent in Hy zou zijn:

(voor [i (bereik 10)]
(print (+ "'i' staat nu op " (str i))))

Ook kunt u diverse Python-bibliotheken importeren en gebruiken. Bijvoorbeeld:

(importeren besturingssysteem)

(if (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/andere map")
(print "Hé, dat pad is er niet!"))

Python's contextmanagers (Met verklaringen) worden als volgt gebruikt:

(met [[f (open "/tmp/data.in")]]
(afdrukken (.lees f)))

wat gelijk is aan:

met open("/tmp/data.in") als f:
print f.read()

En ja, we hebben Lijstbegrippen! In Python zou je het volgende kunnen doen:

odds_kwadraat = [
pow(num, 2)
voor num reeks(100)
als aantal % 2 == 1]

In Hy kun je dit als volgt doen:

(setv odds-kwadraat
(lijst-comp
(pow num 2)
(num (bereik 100))
(= (% aantal 2) 1)))

; En een voorbeeld dat schaamteloos van een Clojure-pagina is gestolen:
; Laten we alle blokken van een schaakbord opsommen:

(lijst-comp
(, xy)
(x (bereik 8)
y "ABCDEFGH"))

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

Python biedt ondersteuning voor verschillende mooie argumenten en trefwoordargumenten. In Python zouden we dat misschien kunnen doen
zien:

>>> def optioneel_arg(pos1, pos2, trefwoord1=Geen, trefwoord2=42):
... return [pos1, pos2, trefwoord1, trefwoord2]
...
>>> optioneel_arg(1, 2)
[1, 2, Geen, 42]
>>> optioneel_arg(1, 2, 3, 4)
[1, 2, 3, 4]
>>> optioneel_arg(trefwoord1=1, pos2=2, pos1=3, trefwoord2=4)
[3, 2, 1, 4]

Hetzelfde in Hy:

=> (defn optioneel-arg [pos1 pos2 &optioneel trefwoord1 [trefwoord2 42]]
... [pos1 pos2 trefwoord1 trefwoord2])
=> (optioneel-arg 1 2)
[1 2 Geen 42]
=> (optioneel-arg 1 2 3 4)
[1 2 3 4]

Als je een versie van Hy ouder dan 0.10.1 gebruikt (bijvoorbeeld git master), is er ook een leuke nieuwe
syntaxis van trefwoordargument:

=> (optioneel-arg :trefwoord1 1
... :pos2 2
... :pos1 3
... :trefwoord2 4)
[3, 2, 1, 4]

Anders kun je altijd gebruiken dit toepassen. Maar wat is dit toepassen?

Bent u bekend met het binnenkomen? *argumenten en ** kwargs in Python?:

>>> argumenten = [1 2]
>>> kwargs = {"trefwoord2": 3
... "trefwoord1": 4}
>>> optioneel_arg(*args, **kwargs)

Wij kunnen dit reproduceren met dit toepassen:

=> (setv argumenten [1 2])
=> (setv kwargs {"trefwoord2" 3
... "trefwoord1" 4})
=> (optioneel-arg args kwargs toepassen)
[1, 2, 4, 3]

Er is ook een trefwoordargumentconstructie in woordenboekstijl die er als volgt uitziet:

(definieer een andere stijl [&key {"key1" "val1" "key2" "val2"}]
[sleutel1 sleutel2])

Het verschil hier is dat je, omdat het een woordenboek is, niet op specifieke woorden kunt vertrouwen
volgorde van de argumenten.

Hy ondersteunt ook *argumenten en ** kwargs. Python:

def een_func(foo, bar, *args, **kwargs):
afdruk importeren
pprint.pprint((foo, bar, args, kwargs))

Het Hy-equivalent:

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

Ten slotte hebben we natuurlijk lessen nodig! In Python hebben we mogelijk een klasse als:

klasse FooBar(object):
"" "
Nog een voorbeeldklasse
"" "
def __init__(zelf, x):
zelf.x = x

def get_x(zelf):
"" "
Stuur ons exemplaar van x terug
"" "
retour zelf.x

in hy:

(standaardklasse FooBar [object]
"Nog een voorbeeldklasse"
[[--in het--
(fn [zelf x]
(setv zelf.xx)
; Momenteel nodig voor --init-- omdat __init__ Geen nodig heeft
; Hopelijk gaat dit weg :)
Geen)]

[haal-x
(fn [zelf]
"Retourneer ons exemplaar van x"
zelf.x)]])

U kunt ook attributen op klasseniveau uitvoeren. In Python:

klasse Klant(modellen.Model):
naam = modellen.CharField(max_length=255)
adres = modellen.TextField()
opmerkingen = modellen.TextField()

in hy:

(defclass Klant [modellen.Model]
[[naam (modellen.CharField:max-lengte 255})]
[adres (modellen.TextField)]
[opmerkingen (modellen.TextField)]])

Hy <-> Python interop
Door Hy te importeren, kun je Hy rechtstreeks vanuit Python gebruiken!

Als u het volgende opslaat in groetjes.hy:

(defn greet [naam] (print "hallo van hy", naam))

Dan kun je het direct vanuit Python gebruiken, door hy te importeren voordat je de module importeert. In
Python:

importeren hy
begroetingen importeren

groeten.greet("Foo")

Je kunt ook een functie declareren in Python (of zelfs een klasse!) en deze gebruiken in Hy!

Als u het volgende opslaat in groeten.py in Python:

def groet(naam):
print("hallo, %s" % (naam))

Je kunt het gebruiken in Hy:

(begroetingen importeren)
(.groet groeten "foo")

Om trefwoordargumenten te gebruiken, kunt u in groeten.py:

def greet(naam, titel="Meneer"):
print("Gegroet, %s %s" % (titel,naam))

(begroetingen importeren)
(.groet groeten "Foo")
(.groet groeten "Foo" "Darth")
(toepassen (. groeten) ["Foo"] {"titel" "Heer"})

Wat zou opleveren:

Gegroet, meneer Foo

Gegroet, Darth Foo

Gegroet, Heer Foo

Protips!
Hy beschikt ook over iets dat bekend staat als de "threading macro", een heel leuk kenmerk van
van Clojure. De "threading macro" (geschreven als ->) wordt gebruikt om diep nestelen te voorkomen
uitdrukkingen.

De threading-macro voegt elke expressie in het eerste argument van de volgende expressie in
plaats.

Laten we de klassieker nemen:

(lus (afdrukken (evalueren (lezen))))

In plaats van het zo te schrijven, kunnen we het als volgt schrijven:

(-> (lezen) (eval) (afdrukken) (lus))

Nu, met behulp van python-sh, kunnen we laten zien hoe de threading-macro (vanwege de opstelling van Python-sh)
kan worden gebruikt als een pijp:

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

Wat zich uiteraard uitbreidt naar:

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

Veel leesbaarder toch? Gebruik de draadrijgmacro!

HY STIJL GUIDE

'Weet u, minister, ik ben het in veel opzichten niet eens met Perkamentus... maar u kunt niet ontkennen dat hij dat wel is
kreeg stijl…’ – Phineas Nigellus Black, Harry pottenbakker en de Bestelling of de Phoenix

De Hy-stijlgids is bedoeld als een set basisregels voor de Hyve (ja, de Hy-gemeenschap).
is er trots op Hy aan alles toe te voegen) om idiomatische Hy-code te schrijven. Hy levert veel op
van Clojure & Common Lisp, terwijl de Python-interopabiliteit altijd behouden blijft.

Inleiding
De Tao of Hy
Ummon vroeg de hoofdmonnik: 'Over welke soetra geef je een lezing?'
"De Nirvana Soetra."
'De Nirvana Sutra heeft de vier deugden, nietwaar?'
"Het heeft."
Ummon vroeg, terwijl hij een kopje oppakte: 'Hoeveel deugden heeft dit?'
‘Helemaal geen,’ zei de monnik.
'Maar oude mensen zeiden van wel, nietwaar?' zei Ummon.
'Wat vind je van wat ze zeiden?'
Ummon sloeg tegen de beker en vroeg: 'Begrijp je dat?'
‘Nee,’ zei de monnik.
'Dan,' zei Ummon, 'kun je maar beter doorgaan met je lezingen over de soetra.'
— de (koan)macro

Het volgende illustreert een korte lijst met ontwerpbeslissingen die zijn genomen bij het maken van dit product
Hy.

· Zie eruit als een Lisp; DTRT ermee (bijvoorbeeld streepjes veranderen in onderstrepingstekens, oorkappen veranderen in
in hoofdletters).

· We zijn nog steeds Python. De meeste internals vertalen 1:1 naar Python-internals.

· Gebruik overal Unicode.

· Herstel de slechte beslissingen in Python 2 wanneer we kunnen (zie ware_divisie).

· Als u twijfelt, ga dan uit van Python.

· Als u nog steeds niet zeker bent, ga dan naar Clojure.

· Als u nog onzekerder bent, ga dan naar Common Lisp.

· Houd er rekening mee dat we niet Clojure zijn. Wij zijn geen gewone Lisp. Wij zijn Homoiconische Python, met
extra stukjes die zinvol zijn.

Layout & deuk
· Vermijd spaties. Ze zuigen!

· De inspringing bedraagt ​​2 spaties (geen harde tabs), behalve wanneer de inspringing overeenkomt met
de vorige regel.

;; Goed (en de voorkeur)
(definieer fib [n]
(als (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Nog steeds oké
(definieer fib [n]
(als (<= n 2) n (+ (fib (- n 1)) (fib (- n 2)))))

;; Nog steeds oké
(definieer fib [n]
(als (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Hysterisch belachelijk
(definieer fib [n]
(als (<= n 2)
N ;; Ja, ik hou ervan om willekeurig op de spatiebalk te drukken
(+ (fib (- n 1)) (fib (- n 2)))))

· Haakjes moeten nooit alleen gelaten worden, verdrietig en eenzaam op hun eigen lijn.

;; Goed (en de voorkeur)
(definieer fib [n]
(als (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Hysterisch belachelijk
(definieer fib [n]
(als (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))
)
); GAH, VERBRAND HET MET VUUR

· Verticaal uitlijnen laten blokken.

(laat [[foo (bar)]
[qux (baz)]]
(foe qux))

· Inline-opmerkingen moeten twee spaties vanaf het einde van de code staan; ze moeten altijd een hebben
ruimte tussen het commentaarteken en het begin van de opmerking. Probeer het ook niet te doen
commentaar op het voor de hand liggende.

;; Goed
(setv ind (dec x)) ; indexering begint vanaf 0

;; Stijlvol, maar vermeldt gewoon het voor de hand liggende
(setv ind (dec x)) ; stelt de index in op x-1

;; Slecht
(setv ind (dec x));woorden typen voor de lol

codering Style
· Probeer het als afspraak niet te gebruiken def voor iets anders dan globale variabelen; gebruik setv
binnenfuncties, loops, enz.

;; Goed (en de voorkeur)
(def *limiet* 400000)

(definieer leugens [ab]
(terwijl het waar is
(opbrengst a)
(setv (, ab) (, b (+ ab)))))

;; Slecht (en niet de voorkeur)
(definieer leugens [ab]
(terwijl het waar is
(opbrengst a)
(def (, ab) (, b (+ ab)))))

· Gebruik geen s-expressiesyntaxis waar vectorsyntaxis is bedoeld. Het feit bijvoorbeeld
dat de eerste van deze twee voorbeelden werkt, is alleen maar omdat de compiler niet overdreven is
streng. In werkelijkheid is de juiste syntaxis op plaatsen zoals deze de laatste.

;; Slecht (en kwaad)
(defn foo (x) (print x))
(foe 1)

;; Goed (en de voorkeur)
(defn foo [x] (print x))
(foe 1)

· Gebruik de draadrijgmacro of de draadrijgstaartmacro's als u diep geneste draad tegenkomt
s-expressies. Wees echter verstandig bij het gebruik ervan. Gebruik ze wanneer duidelijkheid en
de leesbaarheid verbetert; construeer geen ingewikkelde, moeilijk te begrijpen uitdrukkingen.

;; Voorkeur
(def *namen*
(met [f (open "namen.txt")]
(-> (.read f) (.strip) (.replace "\"" "") (.split ",") (gesorteerd))))

;; Niet zo goed
(def *namen*
(met [f (open "namen.txt")]
(gesorteerd (.split "," (.replace "\"" "" (.strip (.read f)))))))

;; Waarschijnlijk geen goed idee
(definieer vierkant? [x]
(->> 2 (pow (int (sqrt x))) (= x)))

· Puntnotatie in Clojure-stijl heeft de voorkeur boven het rechtstreeks aanroepen van de methode van het object,
hoewel beide ondersteund zullen blijven.

;; Goed
(met [fd (open "/ Etc / passwd")]
(afdrukken (.readlines fd)))

;; Niet zo goed
(met [fd (open "/ Etc / passwd")]
(afdrukken (fd.readlines)))

Conclusie
“Mode vervaagt, stijl is eeuwig” – Yves Saint Laurent

Deze gids is slechts een reeks gemeenschapsrichtlijnen, en dat geldt uiteraard ook voor de gemeenschapsrichtlijnen
heeft geen zin zonder een actieve gemeenschap. Bijdragen zijn welkom. Bezoek ons ​​op #hyin
freenode, blog erover, tweet erover en, belangrijker nog, veel plezier met Hy.

Bedankt
· Deze gids is sterk geïnspireerd @paultag 's blogpost Hy Overleving Gids

· De Clojure Style Gids

DOCUMENTATIE INDEX

Inhoud:

commando Lijn Interface
hy
commando Lijn Opties
-c
Voer de Hy-code uit commando.

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

-i
Voer de Hy-code uit commandoen blijf dan in REPL.

-m
Voer de Hy-code uit module, waaronder definiëren indien gedefinieerd.

De -m flag beëindigt de optielijst zodat alle argumenten na de module naam
worden doorgegeven aan de module in sys.argv.

Nieuw in versie 0.10.2.

--spion Druk gelijkwaardige Python-code af voordat u deze uitvoert. Bijvoorbeeld:

=> (defn salutationsnm [naam] (print (+ "Hy " naam "!")))
def salutationsnm(naam):
return print(((u'Hy ' + naam) + u'!'))
=> (aanhefnm "UwNaam")
salutationsnm(u'UwNaam')
Hy JouwNaam!
=>

Nieuw in versie 0.9.11.

--show-tracebacks
Uitgebreide tracebacks afdrukken voor Hy-uitzonderingen.

Nieuw in versie 0.9.12.

-v Druk het Hy-versienummer af en sluit af.

hyc
commando Lijn Opties
bestand[, bestandN]
Compileer Hy-code naar Python-bytecode. Sla de volgende code bijvoorbeeld op als
hynaam.hy:

(definieer hy-hy [naam]
(print (+ "Hy " naam "!")))

(hy-hy "Afroman")

Voer dan uit:

$ hyc hyname.hy
$ python hyname.pyc
Hé Afroman!

hy2py
Nieuw in versie 0.10.1.

commando Lijn Opties
-s

--met-bron
Toon de geparseerde bronstructuur.

-a

--met-ast
Toon de gegenereerde AST.

-bijv

--zonder-python
Laat de Python-code die is gegenereerd door de AST niet zien.

Hy (De taal)
WAARSCHUWING:
Dit is onvolledig; Overweeg alstublieft om bij te dragen aan de documentatie-inspanning.

Theorie of Hy
Hy behoudt boven al het andere 100% compatibiliteit in beide richtingen met Python
zelf. Alle Hy-code volgt een paar eenvoudige regels. Onthoud dit, want het zal binnenkomen
handig.

Deze regels zorgen ervoor dat de Hy-code idiomatisch is en in beide talen kan worden gekoppeld.

· Symbolen in oorbeschermers worden vertaald naar de hoofdletterversie van die tekenreeks. Voor
voorbeeld, foo zal worden FOO.

· UTF-8-entiteiten worden gecodeerd met punycode en voorafgegaan door hy_. Bijvoorbeeld, ⚘
zal worden hy_w7h, ♥ zal worden hy_g6h en ik♥u zal worden hy_iu_t0x.

· Bij symbolen die streepjes bevatten, worden deze vervangen door onderstrepingstekens. Bijvoorbeeld,
render-sjabloon zal worden render_sjabloon. Dit betekent dat symbolen met streepjes dat wel doen
schaduw hun onderstrepingsequivalenten, en vice versa.

Ingebouwde onderdelen
Hy beschikt over een aantal speciale formulieren die worden gebruikt om de juiste Python AST te genereren.
Hieronder volgen 'speciale' vormen, die enigszins onverwacht gedrag kunnen vertonen
sommige situaties.

.
Nieuw in versie 0.10.0.

. wordt gebruikt om attribuuttoegang op objecten uit te voeren. Het maakt gebruik van een kleine DSL om snel verbinding te maken
toegang tot attributen en items in een geneste datastructuur.

Bijvoorbeeld,

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

Compileert tot:

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

. compileert zijn eerste argument (in het voorbeeld foo) als het object waarop het moet worden uitgevoerd
attribuut dereferentie. Het gebruikt kale symbolen als attributen om toegang toe te krijgen (in het voorbeeld bars,
baz, fooien), en compileert de inhoud van lijsten (in het voorbeeld [(+ 1 2)]) voor indexatie.
Andere argumenten veroorzaken een compilatiefout.

Toegang tot onbekende attributen genereert een AttribuutFout. Toegang tot onbekende sleutels genereert een
IndexFout (op lijsten en tupels) of a Sleutelfout (over woordenboeken).

->
-> (Of threading macro) wordt gebruikt om het nesten van expressies te voorkomen. De draadmacro
voegt elke expressie in op de eerste argumentplaats van de volgende expressie. Het volgende
code laat dit zien:

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

- >>
- >> (Of threading staart macro) lijkt op de threading macro, maar in plaats van
Door elke expressie in te voegen in het eerste argument van de volgende expressie, wordt deze toegevoegd als de
laatste argument. De volgende code demonstreert dit:

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

dit toepassen
dit toepassen wordt gebruikt om een ​​optionele lijst met argumenten en een optioneel woordenboek met kwargs toe te passen
naar een functie.

Gebruik: (van toepassing zijn fn-naam [argumenten] [kwargs])

Voorbeelden:

(defn thunk []
"Hé daar")

(pas toe, thunk)
;=> "Hé daar"

(defn totale aankoop [prijs bedrag &optioneel [kosten 1.05] [btw 1.1]]
(* prijs bedrag kosten btw))

(totaalaankoop [10 15] toepassen)
;=> 173.25

(totaal-aankoop toepassen [10 15] {"btw" 1.05})
;=> 165.375

(totaal-aankoop toepassen [] {"prijs" 10 "bedrag" 15 "btw" 1.05})
;=> 165.375

en
en wordt gebruikt in logische expressies. Er zijn minimaal twee parameters nodig. Als alle parameters
evalueren naar Waar, wordt de laatste parameter geretourneerd. In elk ander geval is dit de eerste valse waarde
zal worden geretourneerd. Voorbeeldgebruik:

=> (en waar niet waar)
Niet waar

=> (en Waar Waar)
Waar

=> (en Waar 1)
1

=> (en Waar [] Onwaar Waar)
[]

NOTITIE:
en kortsluiting en stopt met het evalueren van parameters zodra de eerste fout is
tegengekomen.

=> (en False (print "hallo"))
Niet waar

beweren
beweren wordt gebruikt om de omstandigheden te verifiëren terwijl het programma draait. Als de voorwaarde dat niet is
ontmoet, een BeweringFout wordt verhoogd. beweren kan een of twee parameters aannemen. De eerste
parameter is de voorwaarde die moet worden gecontroleerd, en deze moet naar een van beide resulteren Waar or Niet waar. De
tweede parameter, optioneel, is een label voor de bewering, en is de tekenreeks die dat zal zijn
opgegroeid met de BeweringFout. Bijvoorbeeld:

(beweren (= variabele verwachte waarde))

(beweren onwaar)
; BeweringFout

(beweren (= 1 2) "één moet gelijk zijn aan twee")
; AssertionError: één moet gelijk zijn aan twee

Assoc
Assoc wordt gebruikt om een ​​sleutel te koppelen aan een waarde in een woordenboek of om een ​​index van een lijst in te stellen
naar een waarde. Er zijn minstens drie parameters nodig: de gegevens structuur te wijzigen, een sleutel
or indexEn een waarde. Als er meer dan drie parameters worden gebruikt, wordt deze in paren gekoppeld.

Voorbeelden van gebruik:

=>(laat [[verzameling {}]]
... (associatiecollectie "Hond" "Bark")
... (printcollectie))
{u'Hond': u'Bark'}

=>(laat [[verzameling {}]]
... (assoc collectie "Hond" "Bark" "Kat" "Miauw")
... (printcollectie))
{u'Cat': u'Miauw', u'Hond': u'Bark'}

=>(laat [[verzameling [1 2 3 4]]]
... (assoc collectie 2 Geen)
... (printcollectie))
[1, 2, Geen, 4]

NOTITIE:
Assoc wijzigt de aanwezige datastructuur en retourneert Geen.

breken
breken wordt gebruikt om uit een lus te breken. Het beëindigt de lus onmiddellijk. Het volgende
voorbeeld heeft een oneindige en lus die wordt beëindigd zodra de gebruiker binnenkomt k.

(terwijl True (if (= "k" (onbewerkte invoer "? "))
(pauze)
(print "Probeer opnieuw")))

cond
cond kan worden gebruikt om genest te bouwen if verklaringen. Het volgende voorbeeld toont de
relatie tussen de macro en zijn uitbreiding:

(cond [voorwaarde-1 resultaat-1]
[voorwaarde-2 resultaat-2])

(als voorwaarde-1 resultaat-1
(indien voorwaarde-2 resultaat-2))

Zoals hieronder weergegeven, wordt alleen het eerste overeenkomende resultaatblok uitgevoerd.

=> (defn controlewaarde [waarde]
... (cond [(< waarde 5) (print "waarde is kleiner dan 5")]
... [(= waarde 5) (print "waarde is gelijk aan 5")]
... [(> waarde 5) (print "waarde is groter dan 5")]
... [Waar (print "waarde is iets dat het niet zou moeten zijn")]))

=> (controlewaarde 6)
waarde is groter dan 5

voortzetten
voortzetten retourneert de uitvoering naar het begin van een lus. In het volgende voorbeeld
(bijwerking1) wordt voor elke iteratie opgeroepen. (bijwerking2)Er wordt echter alleen een beroep op gedaan
elke andere waarde in de lijst.

;; ervan uitgaande dat (bijwerking1) en (bijwerking2) functies en zijn
;; verzameling is een lijst met numerieke waarden

(voor [x collectie]
(doen
(bijwerking1 x)
(als (% x 2)
(doorgaan))
(bijwerking2 x)))

dict-comp
dict-comp wordt gebruikt om woordenboeken te maken. Er zijn drie of vier parameters nodig. De eerste
twee parameters zijn voor het regelen van de retourwaarde (sleutelwaardepaar), terwijl de derde dat is
gebruikt om items uit een reeks te selecteren. De vierde en optionele parameter kan hiervoor worden gebruikt
filter enkele items in de reeks uit op basis van een voorwaardelijke expressie.

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

do / prog
do en prog worden gebruikt om elk van hun argumenten te evalueren en de laatste terug te geven. Opbrengst
waarden van alle andere argumenten dan het laatste argument worden weggegooid. Het kan gebruikt worden lambda or
lijst-comp om complexere logica uit te voeren, zoals weergegeven in een van de volgende voorbeelden.

Enkele voorbeelden van gebruik:

=> (indien waar
... (doen (print "Bijwerkingen rocken!")
... (afdruk "Ja, echt waar!")))
Bijwerkingen rocken!
Ja echt!

;; ervan uitgaande dat (neveneffect) een functie is die we voor elk willen oproepen
;; en elke waarde in de lijst, maar waarvan de retourwaarde ons niet interesseert
=> (lijst-comp (doen (bijwerking x)
... (als (< x 5) (* 2 x)
... (* 4x)))
... (x (bereik 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do kan een willekeurig aantal argumenten accepteren, van 1 tot n.

def / setv
def en setv worden gebruikt om een ​​waarde, object of functie aan een symbool te binden. Bijvoorbeeld:

=> (def namen ["Alice" "Bob" "Charlie"])
=> (print namen)
[u'Alice', u'Bob', u'Charlie']

=> (setv-teller (fn [verzamelitem] (.count verzamelitem)))
=> (teller [1 2 3 4 5 2 3] 2)
2

defklasse
Nieuwe klassen worden gedeclareerd met defklasse. Er kunnen twee optionele parameters nodig zijn: een vector
het definiëren van mogelijke superklassen en een andere vector die attributen van de nieuwe bevat
klasse als twee itemvectoren.

(defklasse klassenaam [superklasse-1 superklasse-2]
[[Attribuutwaarde]])

Zowel waarden als functies kunnen aan de nieuwe klasse worden gebonden, zoals weergegeven in het onderstaande voorbeeld:

=> (defclass Cat []
... [[leeftijd Geen]
... [kleur "wit"]
... [spreek (fn [zelf] (print "Miauw"))]])

=> (def plek (Cat))
=> (setv spot.kleur "Zwart")
'Zwart'
=> (.spreekplek)
mauw

def / ontkrachten
def en ontkrachten macro's worden gebruikt om functies te definiëren. Ze nemen drie parameters: de naam
van de te definiëren functie, een vector van parametersEn lichaam van de functie:

(defn naam [params] body)

Voor parameters kunnen de volgende trefwoorden staan:

&optioneel
Parameter is optioneel. De parameter kan worden opgegeven als een lijst met twee items, waarbij de
het eerste element is de parameternaam en het tweede is de standaardwaarde. De parameter
kan ook als één item worden opgegeven, in welk geval de standaardwaarde is Geen.

=> (defn totale waarde [waarde &optioneel [belasting over de toegevoegde waarde 10]]
... (+ (/ (* waarde BTW) 100) waarde))

=> (totale waarde 100)
110.0

=> (totale waarde 100 1)
101.0

&toets

&kwars
De parameter bevat 0 of meer trefwoordargumenten.

De volgende codevoorbeelden definiëren een functie die alle trefwoorden afdrukt
argumenten en hun waarden.

=> (defn printparameters [&kwargs kwargs]
... (voor [(, kv) (.items kwargs)] (print kv)))

=> (printparameters toepassen [] {"parameter-1" 1 "parameter-2" 2})
parameter-2 2
parameter-1 1

&rest Parameter bevat 0 of meer positionele argumenten. Geen andere positionering
argumenten kunnen hierna worden gespecificeerd.

Het volgende codevoorbeeld definieert een functie die numeriek van 0 tot n kan worden gegeven
parameters. Vervolgens wordt elk oneven getal bij elkaar opgeteld en elk even getal afgetrokken.

=> (defn zig-zag-som [&rest getallen]
(laat [[oneven getallen (lijst-comp x [x getallen] (oneven? x))]
[even getallen (lijst-comp x [x getallen] (even? x))]]
(- (som oneven getallen) (som even getallen))))

=> (zigzag-som)
0
=> (zigzag-som 3 9 4)
8
=> (zigzag-som 1 2 3 4 5 6)
-3

defn-alias / defun-alias
Nieuw in versie 0.10.0.

De defn-alias en defun-alias macro's lijken veel op def, met het onderscheid dat
in plaats van een functie met één enkele naam te definiëren, kunnen deze ook aliassen definiëren. Ander
dan een lijst met symbolen voor functienamen als eerste parameter te nemen, defn-alias en
defun-alias zijn niet anders dan def en ontkrachten.

=> (defn-alias [hoofdnaamalias] []
... (druk "Hallo!"))
=> (hoofdnaam)
"Hallo!"
=> (alias)
"Hallo!"

definiëren
Nieuw in versie 0.10.1.

De definiëren macro definieert een hoofdfunctie die onmiddellijk wordt aangeroepen sys.argv as
argumenten als en alleen als dit bestand als script wordt uitgevoerd. Met andere woorden, dit:

(defmain [&rest argumenten]
(doe-iets-met argumenten))

is het equivalent van:

def hoofd(*args):
doe_iets_met(args)
terugkeer 0

als __naam__ == "__main__":
import sys
retval = main(*sys.arg)

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

Merk op dat, zoals u hierboven kunt zien, dit het geval zal zijn als u een geheel getal uit deze functie retourneert
gebruikt als de afsluitstatus voor uw script. (Python verlaat standaard status 0, anders
wat betekent dat alles in orde is!)

(Sinds (sys.exit 0) wordt niet expliciet uitgevoerd in het geval van een niet-geheel getal als resultaat van
definiëren, het is een goed idee om te plaatsen (definiëren) als het laatste stukje code in uw bestand.)

defmacro
defmacro wordt gebruikt om macro's te definiëren. Het algemene formaat is (defmacro naam [parameters]
expr).

Het volgende voorbeeld definieert een macro die kan worden gebruikt om de volgorde van elementen in code om te wisselen:
waardoor de gebruiker code kan schrijven in infix-notatie, waarbij de operator tussen de
operanden.

=> (defmacro tussenvoegsel [code]
... (quasiquote (
... (quote verwijderen (krijg code 1))
... (quote verwijderen (krijg code 0))
... (quote verwijderen (krijg code 2)))))

=> (tussenvoegsel (1 + 1))
2

defmacro-alias
defmacro-alias wordt gebruikt om macro's met meerdere namen (aliassen) te definiëren. Het algemene formaat
is (defmacro-alias [namen] [parameters] expr). Het creëert meerdere macro's met hetzelfde
parameterlijst en hoofdtekst, onder de opgegeven lijst met namen.

In het volgende voorbeeld worden twee macro's gedefinieerd, waarin de gebruiker beide code kan schrijven
infix-notatie.

=> (defmacro-alias [infix infi] [code]
... (quasiquote (
... (quote verwijderen (krijg code 1))
... (quote verwijderen (krijg code 0))
... (quote verwijderen (krijg code 2)))))

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

defmacro/g!
Nieuw in versie 0.9.12.

defmacro/g! is een speciale versie van defmacro dat wordt gebruikt om automatisch te genereren gensym
voor elk symbool dat begint met g!.

Bijvoorbeeld g!een zou worden (gensym "A").

ONTDEK OOK:
Sectie met behulp van-gensym

ontleider
Nieuw in versie 0.9.12.

ontleider definieert een lezermacro, waardoor u de syntaxis kunt herstructureren of wijzigen.

=> (ontlader ^ [expr] (print expr))
=> #^(1 2 3 4)
(1 2 3)
=> #^"Hallo"
"Hallo"

ONTDEK OOK:
Macro's voor sectielezers

del
Nieuw in versie 0.9.12.

del verwijdert een object uit de huidige naamruimte.

=> (setv foo 42)
=> (del foo)
=> foe
Hertraceren (meest recente oproep als laatste)
Bestand " ", regel 1, in
NameError: naam 'foo' is niet gedefinieerd

del kan ook objecten verwijderen uit toewijzingen, lijsten en meer.

=> (setv-test (lijst (bereik 10)))
=> testen
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (del (deeltest 2 4)) ;; verwijder items van 2 tot en met 4 uitgesloten
=> testen
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "bar"})
=> dic
{"foo": "bar"}
=> (del (krijg dic "foo"))
=> dic
{}

te doen
Nieuw in versie 0.10.1.

te doen wordt gebruikt om een ​​reeks methodeaanroepen naar een object te vereenvoudigen.

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

=> (setv-verzameling [])
=> (.verzameling 1 toevoegen)
=> (.verzameling 2 toevoegen)
=> (.omgekeerde verzameling)
=> verzameling
[2 1]

eval
eval evalueert een expressie tussen aanhalingstekens en retourneert de waarde.

=> (eval '(print "Hallo wereld"))
"Bonjour monde"

evalueren-en-compileren
eval-wanneer-compileren
eerste / auto
eerste en auto zijn macro's voor toegang tot het eerste element van een verzameling:

=> (eerste (bereik 10))
0

For
For wordt gebruikt om een ​​functie aan te roepen voor elk element in een lijst of vector. De resultaten van elk
oproep wordt genegeerd en de For uitdrukking terugkeert Geen in plaats van. De voorbeeldcode wordt herhaald
over Collectie en voor elk element in Collectie roept de bijwerking functie met
element als argument:

;; ervan uitgaande dat (neveneffect) een functie is waarvoor één enkele parameter nodig is
(voor [elementverzameling] (neveneffectelement))

;; for kan een optioneel else-blok hebben
(voor [elementverzameling] (neveneffectelement)
(anders (bijwerking-2)))

De optionele anders blok wordt alleen uitgevoerd als de For lus eindigt normaal. Als de
de executie wordt stopgezet breken anders blok wordt niet uitgevoerd.

=> (voor [element [1 2 3]] (als (<element 3)
... (afdrukelement)
... (pauze))
... (anders (print "lus voltooid")))
1
2

=> (voor [element [1 2 3]] (als (<element 4)
... (afdrukelement)
... (pauze))
... (anders (print "lus voltooid")))
1
2
3
lus klaar

genexpr
genexpr wordt gebruikt om generatorexpressies te maken. Er zijn twee of drie parameters nodig. De
de eerste parameter is de expressie die de retourwaarde bestuurt, terwijl de tweede parameter wordt gebruikt
om items uit een lijst te selecteren. De derde en optionele parameter kan worden gebruikt om uit te filteren
sommige items in de lijst zijn gebaseerd op een voorwaardelijke expressie. genexpr is gelijk aan
lijst-comp, behalve dat het een iterabele retourneert die waarden één voor één evalueert in plaats van
evalueer ze onmiddellijk.

=> (def verzameling (bereik 10))
=> (def gefilterd (genexpr x [x verzameling] (even? x)))
=> (lijst gefilterd)
[0, 2, 4, 6, 8]

gensym
Nieuw in versie 0.9.12.

gensym wordt gebruikt om een ​​uniek symbool te genereren waarmee macro's zonder kunnen worden geschreven
onbedoelde botsingen met variabelenamen.

=> (gensym)
u':G_1235'

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

ONTDEK OOK:
Sectie met behulp van-gensym

krijgen
krijgen wordt gebruikt om toegang te krijgen tot afzonderlijke elementen in lijsten en woordenboeken. krijgen heeft twee parameters nodig:
de gegevens structuur en index or sleutel van het artikel. Het zal dan het overeenkomstige retourneren
waarde uit het woordenboek of de lijst. Voorbeeldgebruik:

=> (laat [[dieren {"hond" "blaffen" "kat" "miauw"}]
... [cijfers ["nul" "één" "twee" "drie"]]]
... (afdrukken (krijg dieren "hond"))
... (afdrukken (krijg nummers 2)))
schors
twee

NOTITIE:
krijgen genereert een KeyError als in een woordenboek wordt gevraagd naar een niet-bestaande sleutel.

NOTITIE:
krijgen genereert een IndexError als een lijst of een tupel wordt opgevraagd voor een index die buiten de lijst valt
grenzen.

globaal
globaal kan worden gebruikt om een ​​symbool als globaal te markeren. Hierdoor kan de programmeur een
waarde omzetten in een globaal symbool. Voor het lezen van een globaal symbool is het niet nodig globaal trefwoord --
alleen toewijzen doet dat.

Het volgende voorbeeld laat zien hoe het globale symbool a krijgt een waarde toegewezen in een functie en
wordt later in een andere functie afgedrukt. Zonder de globaal trefwoord, de tweede functie
zou een geworpen hebben Naamfout.

(defn set-a [waarde]
(globale a)
(stel een waarde in))

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

(set-a 5)
(print-a)

if / als niet
Nieuw in versie 0.10.0: if-not

if wordt gebruikt om voorwaardelijk code te selecteren die moet worden uitgevoerd. Er moet een voorwaarde in staan
blok en het blok dat moet worden uitgevoerd als het voorwaardeblok evalueert Waar. Optioneel,
het kan een laatste blok bevatten dat wordt uitgevoerd als de evaluatie van de voorwaarde plaatsvindt
Niet waar.

als niet is vergelijkbaar, maar het tweede blok wordt uitgevoerd als de voorwaarde while mislukt
het derde en laatste blok wordt uitgevoerd wanneer de test slaagt - in de tegenovergestelde volgorde van if.

Voorbeeld gebruik:

(als (geld over? rekening)
(print "laten we gaan winkelen")
(print "laten we gaan werken"))

(indien niet (geld over? rekening)
(print "laten we gaan werken")
(print "laten we gaan winkelen"))

De waarachtigheid van Python wordt gerespecteerd. Geen, Niet waar, nul van welk numeriek type dan ook, een lege reeks,
en een leeg woordenboek worden beschouwd Niet waar; aan al het andere wordt gedacht Waar.

lisp-als / lif en lisp-zo-niet / leven-niet
Nieuw in versie 0.10.0.

Nieuw in versie 0.10.2: lisp-if-not / lif-not

Voor degenen die de voorkeur geven aan een meer Lispy if clausule, die hebben we lisp-alsof lif. Deze Slechts beschouwt
Geen / nul vals zijn! Alle andere "valse" Python-waarden worden als waar beschouwd.
Omgekeerd hebben wij dat ook gedaan lisp-zo-niet en leven-niet parallel aan if en als niet wat omkeert
de vergelijking.

=> (lisp-if True "true" "false")
"True"
=> (lisp-als False "true" "false")
"True"
=> (lisp-als 0 "waar" "onwaar")
"True"
=> (lisp-als nul "waar" "onwaar")
"vals"
=> (lisp-als Geen "waar" "onwaar")
"vals"
=> (lisp-zo niet nul "waar" "onwaar")
"True"
=> (lisp-indien-niet Geen "waar" "onwaar")
"True"
=> (lisp-zo-niet False "true" "false")
"vals"

; Gelijkwaardig maar korter
=> (lif Waar "waar" "onwaar")
"True"
=> (lif nul "waar" "onwaar")
"vals"
=> (lif-niet Geen "waar" "onwaar")
"True"

importeren
importeren wordt gebruikt om modules te importeren, zoals in Python. Er zijn verschillende manieren waarop importeren wel
worden gebruikt.

;; Importeert elk van deze modules
;;
;; Python:
;; importsysteem
;; importeer os.pad
(importeer sys os.pad)

;; Importeren vanuit een module
;;
;; Python: vanuit os.path bestaat import, isdir, isfile
(importeer [os.path [bestaat isdir isbestand]])

;; Importeren met een alias
;;
;; Python: importeer sys als systest
(importeer [sys:as systest])

;; U kunt zoveel importproducten van verschillende typen vermelden als u wilt.
(importeer [tests.resources [kwtest-functie-met-een-streepje]]
[os.path [bestaat isdir isbestand]]
[sys: als systeemtest])

;; Importeer alle modulefuncties in de huidige naamruimte
(importeren [sys [*]])

lambda / fn
lambda en fn kan worden gebruikt om een ​​anonieme functie te definiëren. De parameters zijn vergelijkbaar met
def: de eerste parameter is een vector van parameters en de rest is de hoofdtekst van de
functie. lambda geeft een nieuwe functie terug. In het volgende voorbeeld een anonieme functie
wordt gedefinieerd en doorgegeven aan een andere functie voor het filteren van de uitvoer.

=> (def mensen [{:naam "Alice" :leeftijd 20}
... {:naam "Bob":leeftijd 25}
... {:naam "Charlie":leeftijd 50}
... {:naam "Dave":leeftijd 5}])

=> (defn display-people [mensenfilter]
... (voor [persoon mensen] (if (filter persoon) (print (:naam persoon)))))

=> (display-mensen mensen (fn [persoon] (< (:leeftijd persoon) 25)))
Alice
Dave

Net als bij normale functiedefinities geldt dat als het eerste element van het lichaam een ​​string is, dit ook het geval is
fungeert als een docstring. Dit is handig voor het geven van docstrings aan klassemethoden.

=> (setv maal drie
... (fn [x]
... "Vermenigvuldigt de invoer met drie en retourneert het resultaat."
... (*x3)))

Dit kan worden bevestigd via de ingebouwde Python-functie hulp functie:

=> (hulp maal drie)
Hulp bij functie times_three:

maal_drie(x)
Vermenigvuldigt de invoer met drie en retourneert het resultaat
(EINDE)

laatste
Nieuw in versie 0.10.2.

laatste kan worden gebruikt voor toegang tot het laatste element van een verzameling:

=> (laatste [2 4 6])
6

laten
laten wordt gebruikt om lexicaal gedefinieerde variabelen te creëren. Ze zijn gemaakt aan het begin van de
laten vorm en houdt op te bestaan ​​na de vorm. Het volgende voorbeeld laat dit zien
gedrag:

=> (laat [[x 5]] (print x)
... (laat [[x 6]] (print x))
... (druk x))
5
6
5

De laten macro heeft twee parameters nodig: een vectordefinitie variabelen en lichaam wat krijgt
uitgevoerd. variabelen is een vector waarbij elk element een enkele variabele of een vector is
het definiëren van een variabel waardepaar. In het geval van een enkele variabele wordt hieraan een waarde toegekend
Geen; anders wordt de opgegeven waarde gebruikt.

=> (laat [x [y 5]] (print xy))
Geen 5

lijst-comp
lijst-comp voert lijstbegrippen uit. Er zijn twee of drie parameters nodig. De eerste
parameter is de expressie die de retourwaarde bestuurt, terwijl de tweede daaraan gewend is
selecteer items uit een lijst. De derde en optionele parameter kan worden gebruikt om er enkele uit te filteren
van de items in de lijst op basis van een voorwaardelijke expressie. Een paar voorbeelden:

=> (def verzameling (bereik 10))
=> (lijst-comp x [x verzameling])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

=> (lijstsamenstelling (* x 2) [x verzameling] (< x 5))
[0, 2, 4, 6, 8]

niet
niet wordt gebruikt in logische expressies. Er is één enkele parameter nodig en deze retourneert een omgekeerde waarde
waarheidswaarde. Als Waar wordt gegeven als een parameter, Niet waar wordt teruggegeven, en omgekeerd.
Voorbeeld gebruik:

=> (niet waar)
Niet waar

=> (niet onwaar)
Waar

=> (niet Geen)
Waar

or
or wordt gebruikt in logische expressies. Er zijn minimaal twee parameters nodig. Het zal de retour sturen
eerste niet-valse parameter. Als een dergelijke waarde niet bestaat, wordt de laatste parameter geretourneerd.

=> (of Waar Onwaar)
Waar

=> (en Onwaar Onwaar)
Niet waar

=> (en Onwaar 1 Waar Onwaar)
1

NOTITIE:
or kortsluiting en stopt met het evalueren van parameters zodra de eerste echte waarde is bereikt
tegengekomen.

=> (of Waar (print "hallo"))
Waar

print
print wordt gebruikt voor uitvoer op het scherm. Voorbeeldgebruik:

(afdruk "Hallo wereld!")

NOTITIE:
print keert altijd terug Geen.

quasicitaat
quasicitaat Hiermee kunt u een formulier citeren, maar ook uitdrukkingen selectief evalueren.
Uitdrukkingen binnen a quasicitaat kan selectief worden geëvalueerd met behulp van unquote (~). De
geëvalueerde vorm kan ook worden gesplitst met behulp van unquote-splitsing (~@). Quasiquote kan ook
geschreven met behulp van het aanhalingsteken (`) symbool.

;; laat `qux' een variabele zijn met waarde (bar baz)
`(foe ~qux)
; gelijk aan '(foo (bar baz))
`(foe ~@qux)
; gelijk aan '(foo bar baz)

citeren
citeren retourneert het formulier dat eraan is doorgegeven zonder het te evalueren. citeren kan alternatief zijn
geschreven met de apostrof (') symbool.

=> (setv x '(print "Hallo wereld"))
; variabele x is ingesteld op expressie en wordt niet geëvalueerd
=> X
(u'print' u'Hallo wereld')
=> (evalueer x)
Hallo Wereld

vereisen
vereisen wordt gebruikt om macro's uit een bepaalde module te importeren. Er is minimaal één parameter nodig
specificeren van de module welke macro's moeten worden geïmporteerd. Er kunnen meerdere modules worden geïmporteerd
met een single vereisen.

In het volgende voorbeeld worden macro's geïmporteerd uit module 1 en module 2:

(vereist module-1 module-2)

rest / cdr
rest en cdr retourneer de verzameling die als argument is doorgegeven zonder het eerste element:

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

set-comp
set-comp wordt gebruikt om sets te maken. Er zijn twee of drie parameters nodig. De eerste parameter is
voor het controleren van de retourwaarde, terwijl de tweede wordt gebruikt om items uit a te selecteren
reeks. De derde en optionele parameter kan worden gebruikt om enkele items uit te filteren
de reeks gebaseerd op een voorwaardelijke uitdrukking.

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

plak
plak kan worden gebruikt om een ​​subset van een lijst te nemen en daaruit een nieuwe lijst te maken. Het formulier
Er is ten minste één parameter nodig die de te segmenteren lijst specificeert. Er kunnen twee optionele parameters zijn
gebruikt om de begin- en eindpositie van de subset te geven. Als ze niet worden geleverd, wordt de
standaardwaarde van Geen zal in plaats daarvan worden gebruikt. De derde optionele parameter wordt gebruikt
controlestap tussen de elementen.

plak volgt dezelfde regels als zijn Python-tegenhanger. Negatieve indices worden meegeteld
beginnend vanaf het einde van de lijst. Enkele voorbeelden van gebruik:

=> (def verzameling (bereik 10))

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

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

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

=> (plakjesverzameling 2 8 2)
[2, 4, 6]

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

Gooi / verhogen
De Gooi or verhogen formulieren kunnen worden gebruikt om een uitzondering tijdens runtime. Voorbeeldgebruik:

(gooien)
; herhaal de laatste uitzondering

(gooi IOError)
; Gooi een IOError

(gooi (IOError "foobar"))
; Gooi een IOError("foobar")

Gooi kan een enkel argument accepteren (an uitzondering klasse of instantie) of geen argumenten voor
verhoog de laatste opnieuw uitzondering.

proberen
De proberen formulier wordt gebruikt om a te starten proberen / vangst blok. Het formulier wordt als volgt gebruikt:

(proberen
(foutgevoelige functie)
(vang [e ZeroDivisionError] (print "Deling door nul"))
(anders (print "geen fouten"))
(eindelijk (druk "helemaal klaar")))

proberen moet er minstens één bevatten vangst blok, en kan optioneel een anders or Tenslotte
blok. Als er een fout optreedt met een overeenkomend catch-blok tijdens de uitvoering van
foutgevoelige functieDat vangst blok zal worden uitgevoerd. Als er geen fouten worden gemeld, wordt de anders
blok wordt uitgevoerd. De Tenslotte blok zal als laatste worden uitgevoerd, ongeacht of er al dan niet een
er is een fout opgetreden.

tenzij
De tenzij macro is een afkorting voor het schrijven van een if verklaring die controleert of het gegeven is
voorwaardelijk is Niet waar. Hieronder ziet u de uitbreiding van deze macro.

(tenzij voorwaardelijke verklaring)

(indien voorwaardelijk
Geen
(doe verklaring))

unquote
Binnen een quasi-geciteerde vorm, unquote dwingt evaluatie van een symbool af. unquote is een alias voor
de tilde (~) symbool.

(definitieve naam "Knuffels")
(quasiquote (= naam (naam niet aanhalingstekens)))
;=> (u'=' u'naam' u'Knuffels')

`(= naam ~naam)
;=> (u'=' u'naam' u'Knuffels')

unquote-splitsing
unquote-splitsing dwingt de evaluatie van een symbool binnen een quasi-geciteerde vorm af, net zoals
unquote. unquote-splitsing kan alleen worden gebruikt als het symbool zonder aanhalingstekens een
iterabele waarde, omdat het die itereerbare waarde "splitst" in de quasi-geciteerde vorm. unquote-splitsing is
alias van de ~@ symbool.

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

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

wanneer
wanneer is gelijk aan tenzij, behalve dat het test wanneer de gegeven voorwaardelijke voorwaarde is Waar. Het is niet
mogelijk om een anders blok in een wanneer macro. Hieronder ziet u de uitbreiding van de
macro.

(bij voorwaardelijke verklaring)

(indien voorwaardelijk (do-instructie))

en
en wordt gebruikt om een ​​of meer blokken uit te voeren zolang aan een voorwaarde wordt voldaan. Het volgende
voorbeeld zal "Hallo wereld!" uitvoeren voor onbepaalde tijd op het scherm:

(terwijl True (print "Hallo wereld!"))

Met
Met wordt gebruikt om de uitvoering van een blok binnen een contextmanager te verpakken. De context
De manager kan vervolgens het lokale systeem op een gecontroleerde manier opzetten en afbreken. De
archetypisch voorbeeld van gebruik Met is bij het verwerken van bestanden. Met kan context binden aan een
argument of negeer het volledig, zoals hieronder weergegeven:

(met [[arg (expr)]] blok)

(met [[(expr)]] blok)

(met [[arg (expr)] [(expr)]] blok)

In het volgende voorbeeld wordt het NIEUWS bestand en druk de inhoud ervan af op het scherm. De
bestand wordt automatisch gesloten nadat het is verwerkt.

(met [[f (open "NIEUWS")]] (print (.lees f)))

met decorateur
met decorateur wordt gebruikt om een ​​functie met een andere te omwikkelen. De functie die de
decoratie moet één enkele waarde accepteren: de functie die wordt versierd, en een nieuwe retourneren
functie. met decorateur heeft minimaal twee parameters nodig: de functie die wordt uitgevoerd
decoratie en de functie die wordt ingericht. Er kan meer dan één decoratiefunctie zijn
toegepast; ze worden toegepast in volgorde van buitenste naar binnenste, dwz. de eerste
decorateur zal de buitenste zijn, enzovoort. Decorateurs met argumenten worden rechtvaardig genoemd
zoals een functieaanroep.

(met-decorateur-decorateur-plezier
(defn een functie [] ...)

(met-decorateur decorateur1 decorateur2 ...
(defn een functie [] ...)

(met-decorateur (decorateur arg) ..
(defn een functie [] ...)

In het volgende voorbeeld inc-decorateur wordt gebruikt om de functie te versieren toevoeging met een
functie die twee parameters nodig heeft en de gedecoreerde functie aanroept met waarden die dat wel zijn
verhoogd met 1. Wanneer het versierd is toevoeging wordt met de waarden 1 en 1 het einde genoemd
resultaat zal zijn 4 (1+1 + 1+1).

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

=> (met-decorateur inc-decorateur (defn toevoeging [ab] (+ ab)))
=> (optelling 1 1)
4
=> (met-decorateur incl2-decorateur incl-decorateur
... (defn toevoeging [ab] (+ ab)))
=> (optelling 1 1)
8

met-gensyms
Nieuw in versie 0.9.12.

met-gensym wordt gebruikt om een ​​set te genereren gensym voor gebruik in een macro. De volgende code:

(met-gensyms [abc]
...)

breidt uit naar:

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

ONTDEK OOK:
Sectie met behulp van-gensym

opleveren
opleveren wordt gebruikt om een ​​generatorobject te maken dat een of meer waarden retourneert. De generator
is itereerbaar en kan daarom worden gebruikt in loops, lijstbegrippen en andere soortgelijke
construeert.

De functie willekeurige nummers laat zien hoe generatoren kunnen worden gebruikt om oneindige reeksen te genereren
zonder een oneindige hoeveelheid geheugen te verbruiken.

=> (defn vermenigvuldig [bases coëfficiënten]
... (voor [[(, basiscoëfficiënt) (ritsbasiscoëfficiënten)]]
... (opbrengst (* basiscoëfficiënt))))

=> (vermenigvuldigen (bereik 5) (bereik 5))


=> (lijst-comp-waarde [waarde (vermenigvuldigen (bereik 10) (bereik 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (willekeurig importeren)
=> (definieer willekeurige getallen [laag hoog]
... (terwijl True (opbrengst (.randint willekeurig laag hoog))))
=> (lijstsamenstelling x [x (neem 15 (willekeurige getallen 1 50))])])
[7, 41, 6, 22, 32, 17, 5, 38, 18, 38, 17, 14, 23, 23, 19]

opbrengst-van
Nieuw in versie 0.9.13.

PYTHON 3.3 EN UP ONLY!

opbrengst-van wordt gebruikt om een ​​subgenerator aan te roepen. Dit is handig als u wilt dat uw coroutine dat ook doet
in staat zijn om zijn processen te delegeren aan een andere coroutine, bijvoorbeeld als je zoiets speciaals gebruikt
asynchrone.

Hy Kern
Kern Functies
maarlaatst
Gebruik: (maarlaatst col)

Retourneert een iterator van alles behalve het laatste item in coll.

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

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

=> (lijst (butlast []))
[]

=> (itertools importeren)
=> (lijst (neem 5 (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

coll?
Nieuw in versie 0.10.0.

Gebruik: (coll? x)

Retourneren Waar if x is itereerbaar en geen string.

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

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

=> (coll? "abc")
Niet waar

tegens
Nieuw in versie 0.10.0.

Gebruik: (nadelen a b)

Geeft een nieuwe cel met auto terug a en cdr b.

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

=> (= 'hd (auto a))
Waar

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

nadelen?
Nieuw in versie 0.10.0.

Gebruik: (nadelen? foe)

Controleert of foo is een tegencel.

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

=> (nadelen? a)
Waar

=> (nadelen? nul)
Niet waar

=> (nadelen? [1 2 3])
Niet waar

december
Gebruik: (dec x)

Retourneert één minder dan x. Gelijk aan (- x 1). Verhoogt Typefout if (Niet (numeriek? X)).

=> (3 december)
2

=> (0 december)
-1

=> (12.3 december)
11.3

demonteren
Nieuw in versie 0.10.0.

Gebruik: (demonteren boom &optioneel [codegen vals])

Dump de Python AST voor gegeven Hy boom naar standaarduitvoer. Indien codegen is Waar, de functie
drukt in plaats daarvan Python-code af.

=> (demonteren '(print "Hallo wereld!"))
Module(
lichaam=[
Expr(waarde=Oproep(func=Naam(id='print'), args=[Str(s='Hallo wereld!')], trefwoorden=[], starargs=Geen, kwargs=Geen))])

=> (demonteren '(print "Hallo wereld!") waar)
print('Hallo wereld!')

leeg?
Gebruik: (leeg? col)

Retourneren Waar if coll is leeg. Gelijk aan (= 0 (alleen col)).

=> (leeg? [])
Waar

=> (leeg? "")
Waar

=> (leeg? (, 1 2))
Niet waar

elk?
Nieuw in versie 0.10.0.

Gebruik: (elk? voor col)

Retourneren Waar if (pred x) is logisch voor iedereen x in collAnders Niet waar. terugkeer Waar
if coll is leeg.

=> (elke? zelfs? [2 4 6])
Waar

=> (elke? zelfs? [1 3 5])
Niet waar

=> (elke? zelfs? [2 4 5])
Niet waar

=> (elke? zelfs? [])
Waar

vlot?
Gebruik: (vlot? x)

Retourneren Waar if x is een vlotter.

=> (zweven? 3.2)
Waar

=> (zweven? -2)
Niet waar

ook al?
Gebruik: (zelfs? x)

Retourneren Waar if x is gelijk. Verhoogt Typefout if (Niet (numeriek? X)).

=> (zelfs? 2)
Waar

=> (zelfs? 13)
Niet waar

=> (zelfs? 0)
Waar

identiteit
Gebruik: (identiteit x)

Retourneert het argument dat aan de functie is opgegeven.

=> (identiteit 4)
4

=> (lijst (kaartidentiteit [1 2 3 4]))
[1 2 3 4]

inc
Gebruik: (incl x)

Retourneert één meer dan x. Gelijk aan (+ x 1). Verhoogt Typefout if (Niet (numeriek? X)).

=> (incl. 3)
4

=> (incl. 0)
1

=> (incl. 12.3)
13.3

voorbeeld?
Gebruik: (voorbeeld? klasse x)

Retourneren Waar if x is een voorbeeld van klasse.

=> (instantie? float 1.0)
Waar

=> (instantie? int 7)
Waar

=> (instantie? str (str "foo"))
Waar

=> (defclass TestClass [object])
=> (setv inst (TestKlasse))
=> (instantie? TestClass inst)
Waar

geheel getal?
Gebruik: (geheel getal? x)

Retourneren Waar if x is een geheel getal. Voor Python 2 is dit een van beide int or lang. Voor Python 3,
Dit is int.

=> (geheel getal? 3)
Waar

=> (geheel getal? -2.4)
Niet waar

doorschieten
Nieuw in versie 0.10.1.

Gebruik: (interleave vervolg1 vervolg2 ...)

Retourneert een iterabele van het eerste item in elk van de reeksen, vervolgens het tweede, enz.

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

=> (lijst (interleave (bereik 1000000) "abc"))
[0, 'een', 1, 'b', 2, 'c']

tussenbeide komen
Nieuw in versie 0.10.1.

Gebruik: (tussenbeide komen item vervolg)

Retourneert een iterabele van de elementen van de reeks, gescheiden door het item.

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

=> (lijst (tussen -1 (bereik 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

itereerbaar?
Gebruik: (itereerbaar? x)

Retourneren Waar if x is itereerbaar. Iterabele objecten retourneren een nieuwe iterator wanneer (iter x) is
genaamd. Contrast met herhaling?.

=> ;; werkt voor snaren
=> (itereerbaar? (str "abcde"))
Waar

=> ;; werkt voor lijsten
=> (itereerbaar? [1 2 3 4 5])
Waar

=> ;; werkt voor tupels
=> (itereerbaar? (, 1 2 3))
Waar

=> ;; werkt voor dictaten
=> (itereerbaar? {:a 1:b 2:c 3})
Waar

=> ;; werkt voor iterators/generatoren
=> (itereerbaar? (herhaal 3))
Waar

herhaling?
Gebruik: (herhaling? x)

Retourneren Waar if x is een iterator. Iterators zijn objecten die zichzelf retourneren als een
iterator wanneer (iter x) wordt genoemd. Contrast met itereerbaar?.

=> ;; werkt niet voor een lijst
=> (iterator? [1 2 3 4 5])
Niet waar

=> ;; maar we kunnen een iter uit de lijst halen
=> (iterator? (iter [1 2 3 4 5]))
Waar

=> ;; werkt niet voor dictaat
=> (iterator? {:a 1:b 2:c 3})
Niet waar

=> ;; maak een iterator van het dictaat
=> (iterator? (iter {:a 1:b 2:c 3}))
Waar

lijst*
Gebruik: (lijst* hoofd &rest staart)

Genereert een keten van geneste tegencellen (een lijst met stippellijnen) die de argumenten bevat. Als de
argumentenlijst bevat slechts één element, retourneer het.

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

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

=> (lijst* 1)
1

=> (nadelen? (lijst* 1 2 3 4))
Waar

macrouitbreiden
Nieuw in versie 0.10.0.

Gebruik: (macrouitbreiden formulier)

Retourneert de volledige macro-uitbreiding van formulier.

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

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

macro-uitbreiding-1
Nieuw in versie 0.10.0.

Gebruik: (macro-uitbreiden-1 formulier)

Retourneert de macro-uitbreiding in één stap van formulier.

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

samensmelten met
Nieuw in versie 0.10.1.

Gebruik: (samensmelten met f &rest kaarten)

Retourneert een kaart die bestaat uit de rest van de kaarten die als eerste zijn samengevoegd. Als er een sleutel voorkomt in
meer dan één kaart, zullen de kaart(en) van laatstgenoemde (van links naar rechts) worden gecombineerd
de mapping in het resultaat door te bellen (f val-in-resultaat val-in-laatste).

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

negatief?
Gebruik: (ongeacht? x)

Retourneren Waar if x kleiner is dan nul. Verhoogt Typefout if (Niet (numeriek? X)).

=> (negatief? -2)
Waar

=> (negatief? 3)
Niet waar

=> (negatief? 0)
Niet waar

nul?
Gebruik: (nul? x)

Retourneren Waar if x is nul / Geen.

=> (nul? nul)
Waar

=> (nul? Geen)
Waar

=> (nul? 0)
Niet waar

=> (setf x nul)
=> (nul? x)
Waar

=> ;; list.append retourneert altijd Geen
=> (nul? (.append [1 2 3] 4))
Waar

geen?
Gebruik: (geen? x)

Retourneren Waar if x is Geen.

=> (geen? Geen)
Waar

=> (geen? 0)
Niet waar

=> (setf x Geen)
=> (geen? x)
Waar

=> ;; list.append retourneert altijd Geen
=> (geen? (.append [1 2 3] 4))
Waar

zoveelste
Gebruik: (nde coll n &optioneel [standaard nul])

Retourneert de n-de item in een verzameling, geteld vanaf 0. Retourneert de standaardwaarde, nul, als
buiten de grenzen (tenzij anders aangegeven). Verhoogt ValueError if n is negatief.

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

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

=> (nul? (nde [1 2 4 7] 5))
Waar

=> (nde [1 2 4 7] 5 "standaard")
'Default'

=> (nde (neem 3 (laat 2 vallen [1 2 3 4 5 6])) 2))
5

=> (nde [1 2 4 7] -1)
Hertraceren (meest recente oproep als laatste)
...
ValueError: Indices voor islice() moeten Geen zijn of een geheel getal: 0 <= x <= sys.maxsize.

numeriek?
Gebruik: (numeriek? x)

Retourneren Waar if x is een numeriek getal, zoals gedefinieerd in Python nummers.Nummer klasse.

=> (numeriek? -2)
Waar

=> (numeriek? 3.2)
Waar

=> (numeriek? "foo")
Niet waar

vreemd?
Gebruik: (vreemd? x)

Retourneren Waar if x is vreemd. Verhoogt Typefout if (Niet (numeriek? X)).

=> (oneven? 13)
Waar

=> (oneven? 2)
Niet waar

=> (oneven? 0)
Niet waar

pos?
Gebruik: (positie? x)

Retourneren Waar if x groter is dan nul. Verhoogt Typefout if (Niet (numeriek? X)).

=> (positie? 3)
Waar

=> (positie? -2)
Niet waar

=> (positie? 0)
Niet waar

tweede
Gebruik: (tweede col)

Retourneert het tweede lid van coll. Gelijk aan (krijgen coll 1).

=> (tweede [0 1 2])
1

sommige
Nieuw in versie 0.10.0.

Gebruik: (sommige voor col)

Retourneert de eerste logisch ware waarde van (pred x) voor enige x in collAnders nul.
Retourneren nul if coll is leeg.

=> (sommige zelfs? [2 4 6])
Waar

=> (nul? (sommige zelfs? [1 3 5]))
Waar

=> (nul? (een identiteit [0 "" []]))
Waar

=> (een identiteit [0 "niet-lege tekenreeks" []])
'niet-lege string'

=> (nul? (sommige zelfs? []))
Waar

draad?
Gebruik: (snaar? x)

Retourneren Waar if x is een touwtje.

=> (string? "foe")
Waar

=> (tekenreeks? -2)
Niet waar

symbool?
Gebruik: (symbool? x)

Retourneren Waar if x is een symbool.

=> (symbool? 'foo)
Waar

=> (symbool? '[abc])
Niet waar

nul?
Gebruik: (nul? x)

Retourneren Waar if x is nul.

=> (nul? 3)
Niet waar

=> (nul? -2)
Niet waar

=> (nul? 0)
Waar

Volgorde Functies
Reeksfuncties kunnen een potentieel oneindige reeks creëren of hierop werken zonder
waarbij de reeks volledig moet worden gerealiseerd in een lijst of een soortgelijke container. Dit doen zij door
een Python-iterator retourneren.

We kunnen de canonieke oneindige Fibonacci-getalgenerator gebruiken als voorbeeld van hoe te gebruiken
enkele van deze functies.

(definieer fib []
(setv een 0)
(set v b 1)
(terwijl het waar is
(opbrengst a)
(setv (, ab) (, b (+ ab)))))

Merk op (terwijl waar ...) lus. Als we dit in de REPL uitvoeren,

=> (fib)


Het aanroepen van de functie retourneert alleen een iterator, maar werkt niet totdat we deze gebruiken.
Het is niet aan te raden zoiets als dit te proberen, omdat de oneindige lus tot het punt doorloopt
verbruikt al het beschikbare RAM-geheugen, of in dit geval totdat ik het heb gedood.

=> (lijst (fib))
[1] 91474 gedood hy

Gebruik om de eerste 10 Fibonacci-getallen te krijgen nemen. Merk op dat nemen geeft ook een generator terug,
dus ik maak er een lijst van.

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

Om het Fibonacci-getal op index 9 te krijgen (beginnend bij 0):

=> (nde (fib) 9)
34

cyclus
Gebruik: (fiets col)

Retourneert een oneindige iterator van de leden van coll.

=> (lijst (neem 7 (cyclus [1 2 3])))
[1, 2, 3, 1, 2, 3, 1]

=> (lijst (neem 2 (cyclus [1 2 3])))
[1, 2]

onderscheiden
Gebruik: (verschillend col)

Retourneert een iterator die alleen de unieke leden bevat coll.

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

=> (lijst (onderscheiden []))
[]

=> (lijst (onderscheiden (iter [ 1 2 3 4 3 5 2 ])))
[1, 2, 3, 4, 5]

laten vallen
Gebruik: (laten vallen n col)

Retourneert een iterator, waarbij de eerste wordt overgeslagen n leden van coll. Verhoogt ValueError if n is
negatief.

=> (lijst (laat 2 vallen [1 2 3 4 5]))
[3, 4, 5]

=> (lijst (laat 4 vallen [1 2 3 4 5]))
[5]

=> (lijst (laat 0 vallen [1 2 3 4 5]))
[1, 2, 3, 4, 5]

=> (lijst (laat 6 vallen [1 2 3 4 5]))
[]

drop-laatste
Gebruik: (drop-laatste n col)

Retourneert een iterator van alles behalve de laatste n artikelen in coll. Verhoogt ValueError if n is
negatief.

=> (lijst (laatste 5 (bereik 10 20)))
[10, 11, 12, 13, 14]

=> (lijst (laatste neerzetten 0 (bereik 5)))
[0, 1, 2, 3, 4]

=> (lijst (laatste neerzetten 100 (bereik 100)))
[]

=> (itertools importeren)
=> (lijst (neem 5 (laatste 100 vallen (itertools.count 10))))
[10, 11, 12, 13, 14]

drop-terwijl
Gebruik: (drop-terwijl voor col)

Retourneert een iterator, waarbij leden van worden overgeslagen coll tot voor is Niet waar.

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

=> (lijst (drop-while numeriek? [1 2 3 Geen "a"])))
[Geen, u'a']

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

filter
Gebruik: (filter voor col)

Retourneert een iterator voor alle items in coll die het predikaat passeren voor.

Zie ook verwijderen.

=> (lijst (filterpositie? [1 2 3 -4 5 -7]))
[1, 2, 3, 5]

=> (lijst (zelfs filteren? [1 2 3 -4 5 -7]))
[2, -4]

vlakken
Nieuw in versie 0.9.12.

Gebruik: (afvlakken col)

Retourneert een enkele lijst met alle items in coll, door alle opgenomen lijsten af ​​te vlakken en/of
tupels.

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

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

herhalen
Gebruik: (herhalen fn x)

Retourneert een iterator van x, fn(x), fn(fn(x)), Etc.

=> (lijst (neem 5 (itereer inc 5)))
[5, 6, 7, 8, 9]

=> (lijst (neem 5 (itereer (fn [x] (* xx)) 5)))
[5, 25, 625, 390625, 152587890625]

dit artikel lezen
Gebruik: (lezen &optioneel [van bestand eof])

Leest de volgende Hy-expressie voor van bestand (standaard op sys.stdin), en kan een
enkele byte als EOF (standaard een lege tekenreeks). Verhoogt EOFEror if van bestand eindigt eerder
een volledige expressie kan worden geparseerd.

=> (lezen)
(+2)
('+' 2 2)
=> (evalueren (lezen))
(+2)
4

=> (importeren io)
=> (standaard buffer (io.StringIO "(+ 2 2)\n(- 2 1)"))
=> (eval (pas lees [] {"from_file" buffer} toe))
4
=> (eval (pas lees [] {"from_file" buffer} toe))
1

=>; ervan uitgaande dat "example.hy" het volgende bevat:
=>; (druk "hallo" af)
=>; (print "vriendjes!")
=> (met [[f (open "voorbeeld.hy")]]
... (poging
... (terwijl het waar is
... (laat [[exp (lees f)]]
... (Doen
... (print "OHY" exp)
... (evaluatie exp))))
... (vang [e EOFError]
... (druk "EOF!"))))
OHY ('afdrukken' 'hallo')
hallo
OHY ('print' 'hyfriends!')
vrienden!
EOF!

verwijderen
Gebruik: (verwijderen voor col)

Retourneert een iterator van coll met elementen die het predikaat passeren, voor, VERWIJDERD.

Zie ook filter.

=> (lijst (oneven verwijderen? [1 2 3 4 5 6 7]))
[2, 4, 6]

=> (lijst (verwijder pos? [1 2 3 4 5 6 7]))
[]

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

herhaling
Gebruik: (herhalen x)

Retourneert een iterator (oneindig) van x.

=> (lijst (neem 6 (herhaal "s")))
[u's', u's', u's', u's', u's', u's']

herhaaldelijk
Gebruik: (herhaaldelijk fn)

Retourneert een iterator door aan te roepen fn Herhaaldelijk.

=> (importeer [willekeurig [randint]])

=> (lijst (neem 5 (herhaaldelijk (fn [] (randint 0 10)))))
[6, 2, 0, 6, 7]

nemen
Gebruik: (nemen n col)

Retourneert een iterator die de eerste bevat n leden van coll. Verhoogt ValueError if n is
negatief.

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

=> (lijst (neem 4 (herhaal "s")))
[u's', u's', u's', u's']

=> (lijst (neem 0 (herhaal "s")))
[]

neem-nth
Gebruik: (neem-nth n col)

Retourneert een iterator die elke bevat n-de lid van coll.

=> (lijst (neem-nde 2 [1 2 3 4 5 6 7]))
[1, 3, 5, 7]

=> (lijst (neem-nde 3 [1 2 3 4 5 6 7]))
[1, 4, 7]

=> (lijst (neem-nde 4 [1 2 3 4 5 6 7]))
[1, 5]

=> (lijst (neem-nde 10 [1 2 3 4 5 6 7]))
[1]

even duren
Gebruik: (neem even voor col)

Retourneert een iterator van coll zolang voor Retourneren Waar.

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

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

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

zipmet
Nieuw in versie 0.9.13.

Gebruik: (ritssluiting fn coll ...)

Gelijkwaardig aan ritssluiting, maar gebruikt een functie met meerdere argumenten in plaats van een tuple te maken. Als
zipmet wordt dan aangeroepen met N verzamelingen fn moet N argumenten accepteren.

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

Lezer Macro's
Reader-macro's geven Lisp de mogelijkheid om de syntaxis direct aan te passen en te wijzigen. Je wilt niet
Poolse notatie? Een lezermacro kan precies dat doen. Wil je Clojure's manier om een
regex? Lezermacro's kunnen dit ook gemakkelijk doen.

Syntaxis
=> (ontlader ^ [expr] (print expr))
=> #^(1 2 3 4)
(1 2 3)
=> #^"Hallo"
"Hallo"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

Hy heeft geen letterlijke betekenis voor tupels. Laten we zeggen dat je het niet leuk vindt (, ...) en wil iets anders. Dit
is een probleem dat reader-macro's op een nette manier kunnen oplossen.

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

Je zou het zelfs kunnen doen zoals Clojure en een letterlijke versie hebben voor reguliere expressies!

=> (herimporteren)
=> (defreader r [expr] `(opnieuw compileren ~expr))
=> #r".*"
<_sre.SRE_Pattern-object op 0xcv7713ph15#>

Implementatie
ontleider neemt een enkel teken als symboolnaam voor de lezermacro; iets langer
zal een fout retourneren. Implementatiegewijs, ontleider breidt zich uit tot een lambda bedekt met een
decorateur. Deze decorateur slaat de lambda op in een woordenboek met de modulenaam en
symbool.

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

# breidt zich uit tot (verzending_lezer_macro ...) waar het symbool en de uitdrukking naartoe worden doorgegeven
de juiste functie.

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

WAARSCHUWING:
Vanwege een beperking in Hy's lexer en parser kunnen lezermacro's de definitie niet opnieuw definiëren
syntaxis zoals ()[]{}. Dit zal hoogstwaarschijnlijk in de toekomst worden aangepakt.

Intern Hy Documentatie
NOTITIE:
Deze bits zijn vooral handig voor mensen die Hy zelf hacken, maar kunnen ook worden gebruikt voor
degenen die dieper graven in macroprogrammering.

Hy Modellen
Introductie naar Hy Modellen
Hy-modellen vormen een zeer dunne laag bovenop reguliere Python-objecten, die de Hy-bron vertegenwoordigen
coderen als gegevens. Modellen voegen alleen bronpositie-informatie toe, en een handvol methoden
ondersteunen schone manipulatie van Hy-broncode, bijvoorbeeld in macro's. Om dat te bereiken
doel, Hy-modellen zijn mixins van een basis Python-klasse en HyObject.

HyObject
hy.models.HyObject is de basisklasse van Hy-modellen. Het implementeert slechts één methode, vervangen,
die de bronpositie van het huidige object vervangt door degene die als argument is doorgegeven.
Hierdoor kunnen we de oorspronkelijke positie bijhouden van uitdrukkingen die worden gewijzigd door
macro's, of dat nu in de compiler is of in pure hy-macro's.

HyObject is niet bedoeld om rechtstreeks te worden gebruikt om Hy-modellen te instantiëren, maar alleen als een mix
voor andere klassen.

Samenstelling Modellen
Lijsten tussen haakjes en haakjes worden door de Hy-parser ontleed als samengestelde modellen.

HyLijst
hy.models.list.HyList is de basisklasse van "itereerbare" Hy-modellen. Het basisgebruik ervan is
tussen haakjes vertegenwoordigen [] lijsten, waarnaar, wanneer gebruikt als een expressie op het hoogste niveau, wordt vertaald
Python geeft letterlijke waarden weer in de compilatiefase.

Het toevoegen van een HyList aan een ander itereerbaar object hergebruikt de klasse van het object aan de linkerkant,
Dit is handig als u bijvoorbeeld Hy-objecten in een macro wilt samenvoegen.

HyExpressie
hy.models.expression.HyExpression erft HyLijst voor tussen haakjes () uitdrukkingen. De
Het compilatieresultaat van deze expressies is afhankelijk van het eerste element van de lijst: the
compiler verzendt expressies tussen speciale formulieren van de compiler, door de gebruiker gedefinieerde macro's en
reguliere Python-functieaanroepen.

HyDict
hy.models.dict.HyDict erft HyLijst voor accolades {} expressies, die compileren
tot een letterlijk Python-woordenboek.

De beslissing om een ​​lijst te gebruiken in plaats van een dictaat als basisklasse voor HyDict maakt het gemakkelijker
manipulatie van dictaten in macro's, met als bijkomend voordeel dat samengestelde uitdrukkingen mogelijk zijn
als dicteertoetsen (zoals bijvoorbeeld de HyExpressie Python-klasse is niet hashbaar).

atomair Modellen
In de invoerstroom worden tekenreeksen tussen dubbele aanhalingstekens geplaatst, met inachtneming van de Python-notatie voor tekenreeksen,
worden geparseerd als een enkel token, dat direct wordt geparseerd als een HyString.

Een ononderbroken reeks tekens, met uitzondering van spaties, haakjes, aanhalingstekens en dubbele aanhalingstekens
en opmerkingen, wordt geparseerd als een identificatie.

Identifiers worden tijdens de parseerfase in atomaire modellen omgezet in de volgende volgorde:

· Hygeheel getal

· HyFloat

· HyComplex (als het atoom niet kaal is j)

· HyKeywoord (als het atoom begint met :)

· HySymbool

HyString
hy.models.string.HyString is de basisklasse van string-equivalente Hy-modellen. Het ook
vertegenwoordigt letterlijke tekenreeksen tussen dubbele aanhalingstekens, "", die worden gecompileerd tot een Unicode-tekenreeks
letterlijke waarden in Python. HyStrings Unicode-objecten overnemen in Python 2, en objecten in string plaatsen
Python 3 (en zijn daarom niet coderingsafhankelijk).

HyString gebaseerde modellen zijn onveranderlijk.

Hy-letterlijke tekenreeksen kunnen meerdere regels bestrijken en worden door de parser als één regel beschouwd
eenheid, met inachtneming van de Python-ontsnappingen voor Unicode-tekenreeksen.

Numerieke Modellen
hy.models.integer.HyInteger vertegenwoordigt gehele getallen (met behulp van de lang typ op Python 2,
en int op Python3).

hy.models.float.HyFloat vertegenwoordigt letterlijke getallen met drijvende komma.

hy.models.complex.HyComplex vertegenwoordigt complexe letterlijke waarden.

Numerieke modellen worden geparseerd met behulp van de overeenkomstige Python-routine en geldige numerieke python
letterlijke letters zullen worden omgezet in hun Hy-tegenhanger.

HySymbool
hy.models.symbol.HySymbol is het model dat wordt gebruikt om symbolen in de Hy-taal weer te geven. Het
erft HyString.

HySymbool objecten worden tijdens de parseerfase verminkt om de interoperabiliteit van Python te bevorderen:

· Symbolen omgeven door sterretjes (*) worden omgezet in hoofdletters;

· Streepjes (-) worden omgezet in onderstrepingstekens (_);

· Eén vraagteken achteraan (?) wordt omgezet in een leidende is_.

Waarschuwing: aangezien het mangelen plaatsvindt tijdens de parseerfase, is het mogelijk om dit te doen
programmatisch HySymbolen genereren die niet kunnen worden gegenereerd met de Hy-broncode. Zo'n
mechanisme wordt door gensym gebruikt om "niet-geïnterneerde" symbolen te genereren.

HyKeywoord
hy.models.keyword.HyKeyword vertegenwoordigt trefwoorden in Hy. Trefwoorden zijn symbolen die beginnen met
a :. De klasse erft HyString.

Om te onderscheiden HyKeywords oppompen van HySymbolen, zonder de mogelijkheid van (onvrijwillige)
clashes, het Unicode-teken voor privégebruik "\uFDD0" wordt voorafgegaan door het trefwoord letterlijk
voor opslag.

NADELEN Cellen
hy.models.cons.HyCons is een weergave van Python-vriendelijk tegens cellen. Nadelen cellen zijn
vooral handig om kenmerken van "gebruikelijke" LISP-varianten zoals Scheme of Common na te bootsen
Lis.

Een tegenscel is een object met twee items, met daarin een auto (hoofd) en een cdr (staart). In sommige Lisp
Bij varianten is de tegencel de fundamentele bouwsteen, en S-uitdrukkingen zijn dat feitelijk ook
weergegeven als gekoppelde lijsten van tegencellen. Dit is bij Hy niet het geval, zoals gebruikelijk
expressies zijn gemaakt van Python-lijsten verpakt in a HyExpressie. Echter, de Hycons
bootst het gedrag van "gebruikelijke" Lisp-varianten als volgt na:

· (nadelen iets nul) is (HyExpressie [iets])

· (nadelen iets sommige-lijst) is ((type sommige-lijst) (+ [iets] een lijst)) (als
sommige-lijst erft van lijst).

· (krijgen (nadelen a b) 0) is a

· (plak (nadelen a b) 1) is b

Hy ondersteunt een syntaxis met een stippellijn, waarbij '(A . b) middel (nadelen 'a 'B) en '(A b . c) middel
(nadelen 'a (nadelen 'b 'C)). Als de compiler een tegencel op het hoogste niveau tegenkomt, gaat deze omhoog
een compilatiefout.

Hycons verpakt de doorgegeven argumenten (car en cdr) in Hy-typen, om de manipulatie ervan te vergemakkelijken
tegens cellen in een macrocontext.

Hy Intern Theorie
Overzicht
De Hy-internals werken door te fungeren als een front-end voor Python-bytecode, zodat Hy zelf
compileert tot Python Bytecode, waardoor een ongewijzigde Python-runtime Hy-code kan uitvoeren,
zonder het zelfs maar te merken.

De manier waarop we dit doen is door Hy te vertalen naar een interne Python AST-datastructuur, en
het bouwen van die AST in Python-bytecode met behulp van modules uit de Python-standaard
bibliotheek, zodat we niet al het werk van de Python-internals voor elke versie hoeven te dupliceren
enkele Python-release.

Hy werkt in vier fasen. De volgende secties behandelen elke stap van Hy, van bron tot
looptijd.

Stappen 1 en 2: Tokenizing en Parsing
De eerste fase van het compileren van Hy is het omzetten van de broncode in tokens waarmee we aan de slag kunnen. Wij
gebruik een project met de naam rply, wat een hele leuke (en snelle) parser is, geschreven in een subset
van Python genaamd rpython.

De lexingcode is allemaal gedefinieerd in hy.lex.lexer. Deze code definieert meestal alleen de Hy
grammatica, en alle eigenlijke moeilijke delen worden verzorgd door rply - we definiëren alleen
"callbacks" voor antwoorden hy.lex.parser, die de gegenereerde tokens neemt en de
Hy-modellen.

Je kunt de Hy-modellen zien als de "AST" voor Hy, het is waar macro's op werken
(direct), en het is wat de compiler gebruikt wanneer hij Hy compileert.

ONTDEK OOK:
sectie Hy Modellen voor meer informatie over Hy-modellen en wat ze betekenen.

Stap voor 3: Hy Compilatie naar Python AST
Dit is waar de meeste magie in Hy plaatsvindt. Dit is waar we Hy AST (de modellen) nemen,
en compileer ze in Python AST. Er gebeuren hier een paar gekke dingen die voorbij een paar werken
problemen in AST, en het werken in de compiler is een van de belangrijkste werkzaamheden die we doen
hebben.

De compiler is een beetje ingewikkeld, dus voel je niet schuldig als je hem niet bij de eerste opname gebruikt,
het kan even duren voordat het goed is.

Het belangrijkste toegangspunt tot de compiler is HyASTCompiler.compileren. Deze methode wordt aangeroepen, en
de enige echte "openbare" methode in de klas (dat wil zeggen, we beloven niet echt de
API buiten die methode).

Sterker nog, zelfs intern komen we bijna nooit direct terug, we forceren bijna altijd
de Hy-boom door compileren, en zal dit vaak doen met subelementen van een expressie
dat we hebben. Het is aan de op type gebaseerde dispatcher om subelementen correct te verzenden.

Alle methoden die een compilatie uitvoeren, zijn gemarkeerd met de @bouwt() decorateur. Jij kan
geef de klasse door van het Hy-model dat het compileert, of je kunt er een string voor gebruiken
uitdrukkingen. Ik zal dit zo even ophelderen.

Voornaam* Stadium Type-verzending
Laten we beginnen in de compileren methode. Het eerste wat we doen is het type van het ding controleren
wij zijn aan het bouwen. We kijken omhoog om te zien of we een methode hebben waarmee we de type() dat wij
hebben, en verzenden naar de methode die het aankan. Als we daar geen methoden voor hebben
Als we dat type bouwen, verhogen we een intern uitzondering.

Als we bijvoorbeeld een HyString, we hebben een bijna 1-op-1 mapping van Hy AST naar Python
AST. De compile_string methode neemt de HyString, en retourneert an ast.Str()
gevuld met de juiste regelnummers en inhoud.

Macro-uitbreiden
Als we een HyExpressie, we zullen proberen te zien of dit een bekende macro is, en erop aandringen dit te hebben
het breidde zich uit door een beroep te doen hy.macros.macroexpanden duw het resultaat er vervolgens weer in
HyASTCompiler.compileren.

Tweede Stadium Expressie-verzending
Het enige bijzondere geval is de HyExpressie, omdat we afhankelijk van elkaar verschillende AST moeten maken
op het betreffende speciale formulier. Wanneer we bijvoorbeeld een (als waar waar vals), wij
moet een genereren ast.Alsen compileer de subknooppunten correct. Dit is waar de @bouwt()
met een String als argument binnenkomt.

Voor de compile_expressie (die wordt gedefinieerd met een @builds(HyExpressie)) zal verzenden
gebaseerd op de string van het eerste argument. Als het eerste argument om wat voor reden dan ook niet geldt
een string, zal het dat geval ook goed afhandelen (hoogstwaarschijnlijk door een uitzondering).

Als de String niet bekend is bij Hy, wordt er standaard een ast.Bel, die het zal proberen
voer een runtime-oproep uit (in Python, zoiets als foe ()).

Problemen Hit Met Python AST
Python AST is geweldig; het is wat ons in staat heeft gesteld om er zo'n krachtig project bovenop te schrijven
Python zonder te hard tegen Python te hoeven vechten. Zoals alles hebben we er een behoorlijk deel van gehad
problemen, en hier is een korte lijst van de meest voorkomende problemen die u tegen kunt komen.

Python onderscheidt tussen verklaringen en Uitdrukkingen.

Dit klinkt misschien niet als een groot probleem - sterker nog, voor de meeste Python-programmeurs zal dit dat wel zijn
wordt al snel een 'nou ja'-moment.

In Python zoiets doen als:

print For x in reeks(10): passerenomdat print drukt uitdrukkingen af, en For is niet een
expressie, het is een controlestroominstructie. Dingen zoals 1 + 1 zijn uitdrukkingen, zoals ze zijn lambda
x: 1 + x, maar ook andere taalfuncties, zoals if, Forof en zijn uitspraken.

Omdat ze geen "waarde" hebben voor Python, maakt dit het werken in Hy moeilijk, omdat ze iets doen
als (afdrukken (als waar waar vals)) is niet alleen gebruikelijk, het wordt ook verwacht.

Als gevolg hiervan mangelen we dingen automatisch met behulp van a Resultaat object, waar wij er een aanbieden ast.stmt
die moeten worden gerund, en een single ast.expr dat kan worden gebruikt om de waarde van wat dan ook te verkrijgen
werd gewoon gelopen. Hy doet dit door tijdens het hardlopen de toewijzing aan dingen te forceren.

Als voorbeeld, de Hy:

(print (indien waar waar onwaar))

Zal veranderen in:

als het klopt:
_mangled_name_here = Waar
anders:
_mangled_name_here = Onwaar

druk hier _verminkte_naam_ af

Oké, dat was een beetje een leugen, aangezien we die verklaring feitelijk omzetten in:

print Waar als Waar anders Onwaar

Door dingen in een ast.expr als we dat kunnen, maar het algemene idee blijft overeind.

Stap voor 4: Python bytecode uitgang en Runtime
Nadat we een Python AST-boom hebben die compleet is, kunnen we proberen deze naar Python te compileren
bytecode door deze er doorheen te duwen eval. Vanaf nu hebben we niet langer de controle, en...
Python zorgt voor alles. Dit is de reden waarom zaken als Python-tracebacks, pdb en
django-apps werken.

Hy Macro's
gebruik gensym For veiliger Macro's
Bij het schrijven van macro's moet men erop letten dat u geen externe variabelen vastlegt of gebruikt
namen van variabelen die mogelijk conflicteren met de gebruikerscode.

We zullen een voorbeeldmacro gebruiken NIF (Zie
http://letoverlambda.com/index.cl/guest/chap3.html#sec_5 voor een meer volledige beschrijving.)
NIF is een voorbeeld, zoiets als een numeriek getal if, waarbij op basis van de uitdrukking een van de
Er worden 3 vormen aangeroepen, afhankelijk van of de uitdrukking positief, nul of negatief is.

Een eerste doorgang zou zoiets kunnen zijn als:

(defmacro nif [expr pos-vorm nulvorm neg-vorm]
`(laat [[onduidelijke naam ~expr]]
(cond [(pos? obscure-naam) ~pos-formulier]
[(nul? obscure naam) ~ nulvorm]
[(neg? obscure-naam) ~neg-vorm])))

WAAR onduidelijke naam is een poging om een ​​variabelenaam te kiezen om niet in conflict te komen met andere
code. Maar hoe goed bedoeld ook, dit is uiteraard geen garantie.

De methode gensym is ontworpen om voor zo’n gelegenheid een nieuw, uniek symbool te genereren.
Een veel betere versie van NIF zou zijn:

(defmacro nif [expr pos-vorm nulvorm neg-vorm]
(laat [[g (gensym)]]
`(laat [[~g ~expr]]
(cond [(pos? ~g) ~pos-vorm]
[(nul? ~g) ~nulvorm]
[(neg? ~g) ~neg-vorm]))))

Dit is een eenvoudig geval, aangezien er maar één symbool is. Maar als er meerdere nodig zijn
gensym's er is een tweede macro met-gensyms die zich feitelijk uitbreidt naar een reeks laten
verklaringen:

(met-gensyms [abc]
...)

breidt uit naar:

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

dus onze herschreven NIF zou er als volgt uitzien:

(defmacro nif [expr pos-vorm nulvorm neg-vorm]
(met-gensyms [g]
`(laat [[~g ~expr]]
(cond [(pos? ~g) ~pos-vorm]
[(nul? ~g) ~nulvorm]
[(neg? ~g) ~neg-vorm]))))

Eindelijk kunnen we een nieuwe macro maken die dit allemaal voor ons doet. defmacro/g! zal nemen
alle symbolen die beginnen met g! en automatisch bellen gensym met de rest van de
symbool. Dus g!een zou worden (gensym "A").

Onze definitieve versie van NIF, gebouwd met defmacro/g! wordt:

(defmacro/g! nif [expr pos-vorm nulvorm neg-vorm]
`(laat [[~g!res ~expr]]
(cond [(pos? ~g!res) ~pos-formulier]
[(nul? ~g!res) ~nulvorm]
[(neg? ~g!res) ~neg-vorm]))))

Controleren Macro argumenten en Het verhogen van Uitzonderingen
Hy Compiler Ingebouwde onderdelen

BIJDRAGER MODULES INDEX

Inhoud:

anaforisch Macro's
Nieuw in versie 0.9.12.

De anaforische macromodule maakt functioneel programmeren in Hy zeer beknopt en eenvoudig
lezen.
Een anaforische macro is een soort programmeermacro die opzettelijk een bepaalde vorm vastlegt
geleverd aan de macro waarnaar kan worden verwezen door een anafoor (een uitdrukking die verwijst naar
naar een ander). — Wikipedia(http://en.wikipedia.org/wiki/Anaphoric_macro)

Macro's
ap-als
Gebruik: (ap-als (foe) (afdrukken Het))

Evalueert de eerste vorm op waarachtigheid en bindt deze daaraan it zowel in het ware als in het onware
takken.

een perzik
Gebruik: (een perzik [1 2 3 4 5] (afdrukken Het))

Evalueer het formulier voor elk element in de lijst op bijwerkingen.

ap-elke-tijd
Gebruik: (ap-elke-tijd lijst voor lichaam)

Evalueer de vorm voor elk element waar de predikaatvorm terugkeert Waar.

=> (ap-elke-terwijl [1 2 3 4 5 6] (< it 4) (print het))
1
2
3

ap-kaart
Gebruik: (ap-kaart formulier lijst)

De anaforische kaartvorm werkt net als een gewone kaart, behalve dat in plaats van een functie
object het heeft een Hy-vorm. De bijzondere naam it is gebonden aan het huidige object uit de
lijst in de iteratie.

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

ap-kaart-wanneer
Gebruik: (ap-kaart-wanneer predfn rep lijst)

Evalueer een mapping over de lijst met behulp van een predikaatfunctie om te bepalen wanneer de
vorm.

=> (lijst (ap-map-wanneer oneven? (* it 2) [1 2 3 4]))
[2, 2, 6, 4]

=> (lijst (ap-map-wanneer zelfs? (* it 2) [1 2 3 4]))
[1, 4, 3, 8]

ap-filter
Gebruik: (ap-filter formulier lijst)

Zoals met ap-kaart we nemen een speciale vorm aan in plaats van een functie om de elementen van de te filteren
lijst. De bijzondere naam it is gebonden aan het huidige element in de iteratie.

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

ap-afwijzen
Gebruik: (ap-afwijzen formulier lijst)

Deze functie doet het tegenovergestelde van ap-filter, het verwerpt de elementen die passeren
predikaat. De bijzondere naam it is gebonden aan het huidige element in de iteratie.

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

ap-dotimes
Gebruik (ap-dotimes n lichaam)

Deze functie evalueert het lichaam n keer, met de speciale variabele it gebonden van 0 naar
1-n. Het is nuttig bij bijwerkingen.

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

ap-eerst
Gebruik (ap-eerst predfn lijst)

Deze functie retourneert het eerste element dat het predikaat or doorgeeft GeenMet
speciale variabele it gebonden aan het huidige element in iteratie.

=>(ap-eerst (> it 5) (bereik 10))
6

ap-laatste
Gebruik (ap-laatste predfn lijst)

Deze functie retourneert het laatste element dat het predikaat or doorgeeft Geen, met de speciale
variabele it gebonden aan het huidige element in iteratie.

=>(ap-laatste (> it 5) (bereik 10))
9

ap-verminderen
Gebruik (ap-verminderen formulier lijst &optioneel beginwaarde)

Deze functie retourneert het resultaat van het toepassen van vorm op de eerste twee elementen in de hoofdtekst en
het resultaat en het derde element enz. toepassen totdat de lijst uitgeput is. Optioneel een
initiële waarde kan worden opgegeven, zodat de functie wordt toegepast op de initiële waarde en de
eerste element in plaats daarvan. Hierdoor wordt het element zichtbaar dat wordt herhaald als it En de huidige
geaccumuleerde waarde als ACC.

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

lus/herhaling
Nieuw in versie 0.10.0.

De lus / terugkeren macro biedt programmeurs een eenvoudige manier om tail-call-optimalisatie (TCO) te gebruiken
in hun Hy-code.
Een staartoproep is een subroutineoproep die als laatste binnen een andere procedure plaatsvindt
actie; het kan een retourwaarde opleveren die vervolgens onmiddellijk wordt geretourneerd door de aanroep
procedure. Als er een oproep is die een subroutine uitvoert, kan deze uiteindelijk leiden
totdat dezelfde subroutine opnieuw in de oproepketen wordt aangeroepen, zich in de staartpositie bevindt,
Van een dergelijke subroutine wordt gezegd dat deze staart-recursief is, wat een speciaal geval van recursie is.
Tail calls zijn belangrijk omdat ze kunnen worden geïmplementeerd zonder een nieuwe stapel toe te voegen
frame naar de call-stack. Het grootste deel van het kader van de huidige procedure is niet nodig
meer, en het kan worden vervangen door het frame van de staartoproep. Het programma kan dan springen
naar de opgeroepen subroutine. Het produceren van een dergelijke code in plaats van een standaard oproepreeks is dat wel
Dit wordt staartoproepeliminatie of staartoproepoptimalisatie genoemd. Eliminatie van staartoproepen maakt dit mogelijk
procedureaanroepen in staartpositie moeten net zo efficiënt worden geïmplementeerd als goto-instructies,
waardoor efficiënt gestructureerd programmeren mogelijk is. — Wikipedia(‐
http://en.wikipedia.org/wiki/Tail_call)

Macro's
lus
lus stelt een recursiepunt vast. Met lus, terugkeren bindt de variabelen die zijn ingesteld in het bestand opnieuw
recursiepunt en stuurt de uitvoering van de code terug naar dat recursiepunt. Als terugkeren wordt gebruikt
een niet-staartpositie wordt een uitzondering gegenereerd.

Gebruik: (lus bindingen &rest lichaam)

Voorbeeld:

(vereist hy.contrib.loop)

(definieer faculteit [n]
(lus [[in] [acc 1]]
(als (nul? ik)
ACC
(herhaling (dec i) (* acc i)))))

(faculteit 1000)

defmulti
Nieuw in versie 0.10.0.

defmulti Hiermee kunt u een functie arity-overbelasten met het opgegeven aantal args en/of kwargs.
Geïnspireerd door de visie van Clojure def.

=> (vereist hy.contrib.multi)
=> (defmulti-fun
... ([een] "een")
... ([ab] "ab")
... ([abc] "abc"))
=> (leuk 1)
"A"
=> (leuk 1 2)
"ab"
=> (leuk 1 2 3)
"abc"

HACKING ON HY

Aanmelden onze Hyve!
Kom alsjeblieft Hy hacken!

Kom alsjeblieft met ons rondhangen #hy on irc.freenode.net!

Praat erover op Twitter met de #hy hashtag!

Blog er alsjeblieft over!

Spuit het alsjeblieft niet op het hek van je buurman (zonder vriendelijk te vragen)!

Hacken!
Doe dit:

1. Maak een virtueel milieu:

$ virtualenv venv

en activeer deze:

$. venv/bin/activeren

of gebruik virtueleenvwrapper om uw virtuele omgeving te creëren en te beheren:

$ mkvirtualenv hy
$ werk aan hy

2. Haal de broncode op:

$ git-kloon https://github.com/hylang/hy.git

of gebruik je vork:

$ git kloon [e-mail beveiligd]: /hy.git

3. Installeren voor hacken:

$ cd hy/
$ pip installatie -e .

4. Installeer andere ontwikkelingsvereisten:

$ pip install -r vereisten-dev.txt

5. Doe geweldige dingen; iemand laten gillen van vreugde/walging over wat je hebt aangericht.

Test!
Tests bevinden zich in testen /. We gebruiken neus-.

Om de tests uit te voeren:

$ neustesten

Schrijf tests --- tests zijn goed!

Het is ook goed om de tests uit te voeren voor alle ondersteunde platforms en voor PEP 8-compatibele platforms
code. U kunt dit doen door tox uit te voeren:

$ tox

Document!
Documentatie bevindt zich in documenten /. We gebruiken Sfinx.

Om de documenten in HTML te bouwen:

$ cd-documenten
$ maak html

Schrijf documenten --- documenten zijn goed! Zelfs deze dokter!

Bijdragende
Bijdragen zijn welkom en worden zeer op prijs gesteld, alle kleine beetjes helpen om Hy meer te maken
geweldig.

Pull-verzoeken zijn geweldig! We houden van ze; hier is een korte handleiding:

· Fork de repository en maak een onderwerpvertakking voor een functie/oplossing. Vermijd het rechtstreeks aanbrengen van wijzigingen
op de mastertak.

· Alle binnenkomende features moeten vergezeld gaan van tests.

· Voordat u een PR indient, voert u de tests uit en controleert u uw code aan de hand van de stijl
gids. U kunt beide dingen tegelijk doen:

$ maak d

· Maak commits in logische eenheden, zodat het later gemakkelijker te volgen en te navigeren is. Voor
als je een PR indient, probeer dan de commits samen te vatten in wijzigingensets waar je gemakkelijk op terug kunt komen
later. Zorg er ook voor dat u geen valse witruimte achterlaat in de wijzigingensets; dit
vermijdt het later aanmaken van witruimtefix-commits.

· Wat betreft commit-berichten, probeer je aan het volgende te houden:

· Probeer je aan de limiet van 50 tekens te houden voor de eerste regel van Git commit-berichten.

· Voor meer details/uitleg, volg dit met een lege regel en ga verder
waarin de commit gedetailleerd wordt beschreven.

· Voeg ten slotte jezelf toe aan het AUTHORS-bestand (als een afzonderlijke commit): je verdient het :)

· Alle binnenkomende wijzigingen moeten worden goedgekeurd door 2 verschillende leden van het kernteam van Hylang.
Aanvullende beoordelingen zijn uiteraard welkom, maar we hebben hiervoor minimaal twee handtekeningen nodig
veranderen.

· Als een kernlid een PR instuurt, zoek dan twee kernleden waarin de
PR-indiener. Het idee hier is dat men kan samenwerken met de PR-auteur, en een tweede acks
de gehele wijzigingsset.

· Voor documentatie en andere triviale wijzigingen is het goed om na één ACK samen te voegen. Wij hebben
lage dekking, dus het zou geweldig zijn om die barrière laag te houden.

Kern Team
Het kernontwikkelteam van Hy bestaat uit de volgende ontwikkelaars:

· Julian Danjou

· Morten Linderud

· J Kenneth koning

· Gergely Nagy

· Toeukka Turto

· karen Roest

· Abhishek L

· Christopher Allan Webber

· Konrad Hinsen

· Zullen Kahn-Greene

· Paul Tagliamonte

· Nicolas Dandrimont

· Bob Tolbert

· Berker Peksag

· Clinton N. Dreisbach

· hij semaj

Gebruik hy online met behulp van onworks.net-services