hy - En ligne dans le cloud

PROGRAMME:

Nom

hy - hy Documentation [image : Hy] [image]

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

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

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

Liste hylang-discuter

IRC #hy sur Freenode

Développer statuts
Travis CI.UNINDENT

Hy est un merveilleux dialecte de Lisp intégré à Python.

Puisque Hy transforme son code Lisp en arbre de syntaxe abstraite Python, vous avez
tout le beau monde de Python à portée de main, sous forme Lisp !

Contenu:

PRISE EN MAIN RAPIDE

[image : Les câlins de Karen Rustard] [image]

(Merci à Karen Rustad pour les câlins !)

COMMENT À ÉCONOMISEZ HY REAL RAPIDE:

1. Créer un Salle de conférence virtuelle Python Environment.

2. Activez votre environnement Python virtuel.

3. Installer hy de PyPI avec pépin installer hy.

4. Démarrez un REPL avec hy.

5. Tapez des éléments dans le REPL :

=> (imprimer "Hy!")
Hy!
=> (defn salutationsnm [nom] (imprimer (+ "Hy " nom "!")))
=> (salutationsnm "VotreNom")
Salut ton nom !

etc

6. Appuyez sur CTRL-D lorsque vous avez terminé.

OMG! C'est incroyable! I souhaitez à écrire a Hy .

7. Ouvrez un éditeur de programmation d'élite et tapez :

(imprimer "J'allais coder en syntaxe Python, mais ensuite j'ai eu Hy.")

8. Enregistrer sous génial.hy.

9. Et exécutez votre premier programme Hy :

hy génial.hy

10.
Respirez profondément pour ne pas hyperventiler.

11.
Souriez méchamment, faufilez-vous dans votre refuge et faites des choses indescriptibles.

TUTORIAL

Bienvenue dans le tutoriel Hy !

En un mot, Hy est un dialecte Lisp, mais qui convertit sa structure en Python...
littéralement une conversion dans l'arbre de syntaxe abstraite de Python ! (Ou pour le dire de manière plus brute
termes, Hy est lisp-stick sur un Python !)

C'est plutôt cool car cela signifie que Hy est plusieurs choses :

· Un Lisp qui semble très pythonique

· Pour Lispers, une excellente façon d'utiliser les pouvoirs fous de Lisp mais dans le vaste monde de Python
bibliothèques (pourquoi oui, vous pouvez désormais écrire une application Django en Lisp !)

· Pour les Pythonistas, une excellente façon de commencer à explorer Lisp, dans le confort de Python !

· Pour tous : un langage agréable qui regorge d'idées sympas !

Basic l'intro à Zézayer en Pythonistes
D'accord, peut-être que vous n'avez jamais utilisé Lisp auparavant, mais vous avez utilisé Python !

Un programme "hello world" dans Hy est en fait super simple. Essayons:

(imprimer "bonjour tout le monde")

Voir? Facile! Comme vous l'avez peut-être deviné, c'est la même chose que la version Python de :

imprimer "Bonjour tout le monde"

Pour additionner quelques calculs super simples, nous pourrions faire :

(+ 1 3)

Ce qui renverrait 4 et serait l'équivalent de :

1 + 3

Ce que vous remarquerez, c'est que le premier élément de la liste est la fonction appelée et le
le reste des arguments sont les arguments transmis. En fait, dans Hy (comme dans la plupart des cas),
Lisps), nous pouvons passer plusieurs arguments à l'opérateur plus :

(+ 1 3 55)

Ce qui retournerait 59.

Peut-être avez-vous déjà entendu parler de Lisp, mais vous n'en savez pas grand-chose. Lisp n'est pas aussi difficile que toi
pourrait penser, et Hy hérite de Python, donc Hy est un excellent moyen de commencer à apprendre Lisp.
La principale chose qui est évidente avec Lisp est qu'il y a beaucoup de parenthèses. Cela pourrait
Cela semble déroutant au début, mais ce n'est pas si difficile. Regardons quelques calculs simples qui sont
enveloppé dans un tas de parenthèses que l’on pourrait saisir dans l’interpréteur Hy :

(résultat setv (- (/ (+ 1 3 88) 2) 8))

Cela renverrait 38. Mais pourquoi ? Eh bien, nous pourrions regarder l'expression équivalente dans
python:

résultat = ((1 + 3 + 88) / 2) - 8

Si vous deviez essayer de comprendre comment ce qui précède devait fonctionner en python, vous le feriez bien sûr
Déterminez les résultats en résolvant chaque parenthèse intérieure. C'est la même idée de base dans
Hy. Essayons d'abord cet exercice en Python :

résultat = ((1 + 3 + 88) / 2) - 8
# simplifié en...
résultat = (92 / 2) - 8
# simplifié en...
résultat = 46 - 8
# simplifié en...
résultat = 38

Essayons maintenant la même chose dans Hy :

(résultat setv (- (/ (+ 1 3 88) 2) 8))
; simplifié en...
(résultat setv (- (/ 92 2) 8))
; simplifié en...
(résultat setv (- 46 8))
; simplifié en...
(résultat setv 38)

Comme vous l'avez probablement deviné, cette dernière expression avec sev signifie affecter la variable
"résultat" à 38.

Voir? Pas trop difficile!

C'est le principe de base de Lisp. Lisp signifie « traitement de liste » ; cela signifie que le
la structure du programme est en fait des listes de listes. (Si vous connaissez Python
listes, imaginez la même structure que ci-dessus mais avec des crochets à la place, n'importe quel
vous pourrez voir la structure ci-dessus à la fois comme un programme et une structure de données.) Ceci est
plus facile à comprendre avec plus d'exemples, alors écrivons un programme Python simple, testons-le,
puis affichez le programme Hy équivalent :

def simple_conversation() :
print "Bonjour ! J'aimerais faire votre connaissance. Parlez-moi de vous !"
name = raw_input("Quel est votre nom ? ")
age = raw_input("Quel est votre âge ? ")
imprimez "Bonjour " + nom + " ! Je vois que vous avez " + âge + " ans. "

simple_conversation()

Si nous exécutions ce programme, cela ressemblerait à :

Bonjour! J'aimerais te connaitre. Parle-moi de toi!
Quel est ton nom? Gary
Quel âge avez-vous? 38
Bonjour Gary ! Je vois que tu as 38 ans.

Regardons maintenant le programme Hy équivalent :

(définition simple-conversation []
(imprimer "Bonjour ! J'aimerais faire votre connaissance. Parlez-moi de vous !")
(nom setv (entrée brute "Quel est votre nom ? "))
(setv age (entrée brute "Quel est votre âge ? "))
(imprimer (+ "Bonjour " nom " ! Je vois que tu es "
âge " ans.")))

(conversation simple)

Si vous regardez le programme ci-dessus, tant que vous vous souvenez que le premier élément de chaque
la liste du programme est la fonction (ou la macro... nous y reviendrons plus tard) appelée
et que le reste ne sont que des arguments, il est assez facile de comprendre ce que tout cela signifie.
(Comme vous l'avez probablement aussi deviné, défn est la méthode Hy de définition des méthodes.)

Pourtant, beaucoup de gens trouvent cela déroutant au début parce qu'il y a tellement de parenthèses,
mais il y a beaucoup de choses qui peuvent rendre cela plus facile : garder l'indentation agréable et
utilisez un éditeur avec correspondance entre parenthèses (cela vous aidera à comprendre ce que chaque
la parenthèse s'associe) et les choses commenceront à se sentir à l'aise.

Il y a certains avantages à avoir une structure de code qui est en fait un fichier de données très simple.
structure sur laquelle est basé le noyau de Lisp. D'une part, cela signifie que vos programmes sont
facile à analyser et que toute la structure réelle du programme est très clairement exposée
pour vous. (Il y a une étape supplémentaire dans hy où la structure que vous voyez est convertie en Python
propres représentations... dans des Lisp "plus purs" tels que Common Lisp ou Emacs Lisp, les données
structure que vous voyez dans le code et la structure de données qui est exécutée est bien plus
littéralement proche.)

Une autre implication de ceci concerne les macros : si la structure d'un programme est un simple fichier de données
structure, cela signifie que vous pouvez écrire du code qui peut écrire du code très facilement, ce qui signifie que
la mise en œuvre de fonctionnalités linguistiques entièrement nouvelles peut être très rapide. Avant Hy, ce n'était pas le cas
très possible pour les programmeurs Python ... maintenant vous aussi pouvez utiliser l'incroyable
puissance (faites juste attention à ne pas les diriger vers le pied) !

Hy is a Au goût de Lisp Python
Hy se convertit en arbre de syntaxe abstraite propre à Python, vous commencerez donc bientôt à trouver tout cela
le pouvoir familier de Python est à portée de main.

Vous avez un accès complet aux types de données et à la bibliothèque standard de Python dans Hy. Expérimentons
avec ceci dans l'interpréteur hy :

=> [1 2 3]
[1, 2, 3]
=> {"chien" "aboiement"
... "chat" "miaou"}

{'chien' : 'aboiement', 'chat' : 'miaou'}
=> (, 1 2 3)
(1, 2, 3)

Si vous êtes familier avec d'autres Lisps, vous serez peut-être intéressé par le fait que Hy prend en charge le Common
Méthode Lisp de citation :

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

Vous avez également accès à toutes les belles méthodes des types intégrés :

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

Qu'est-ce que c'est ça? Oui en effet, c'est exactement la même chose que :

" fooooo ".strip()

C'est vrai --- Lisp avec la notation par points ! Si nous avons cette chaîne assignée comme variable, nous
peut également effectuer les opérations suivantes :

(setv cette chaîne " fooooo ")
(cette-chaîne.strip)

Et les conditions ? :

(si (essaye quelque chose)
(imprimer "c'est si vrai")
(imprimer "c'est si faux"))

Comme vous pouvez le constater ci-dessus, le premier argument de if est un test de vérité, le deuxième argument est
le corps si vrai, et le troisième argument (facultatif !) est si faux (c.-à-d. d'autre).

Si vous avez besoin d'appliquer des conditions plus complexes, vous constaterez que vous n'avez pas Elif
disponible en Hy. Au lieu de cela, vous devriez utiliser quelque chose appelé cond. En Python, vous pourriez faire
quelque chose comme:

unevar = 33
si somevar > 50 :
print "Cette variable est trop grande !"
elif somevar < 10 :
print "Cette variable est trop petite !"
autre:
print "Cette variable est tout simplement correcte !"

En Hy, vous feriez :

(suite
[(> une variable 50)
(imprimer "Cette variable est trop grande!")]
[(< une variable 10)
(imprimer "Cette variable est trop petite!")]
[vrai
(imprimer "Cette variable est tout simplement correcte!")])

Ce que vous remarquerez, c'est que cond s'éteint entre une instruction exécutée et
vérifié conditionnellement pour vrai ou faux, puis un peu de code à exécuter s'il devient
se révèle être vrai. Vous remarquerez également que le d'autre est implémenté à la fin simplement par
vérifier oui -- c'est parce que oui sera toujours vrai, donc si nous arrivons jusqu'ici, nous le ferons
lancez toujours celui-là !

Vous remarquerez peut-être ci-dessus que si vous avez un code tel que :

(si une condition
(corps-si-vrai)
(corps-si-faux))

Mais attendez! Que se passe-t-il si vous souhaitez exécuter plusieurs instructions dans le corps de l'une des
celles-ci?

Vous pouvez effectuer les opérations suivantes :

(si (essaye quelque chose)
(de
(imprimer "c'est si vrai")
(imprimer "et pourquoi pas, continuons à dire à quel point c'est vrai !))
(imprimer "celui-ci est tout simplement faux"))

Vous pouvez voir que nous avons utilisé do pour envelopper plusieurs instructions. Si vous connaissez d'autres
Lips, c'est l'équivalent de prog ailleurs.

Les commentaires commencent par des points-virgules :

(imprimer "cela fonctionnera")
; (imprimer "mais ce ne sera pas le cas")
(+ 1 2 3) ; nous exécuterons l'ajout, mais pas ce commentaire !

Le bouclage n’est pas difficile mais a une sorte de structure particulière. En Python, on pourrait faire :

pour moi dans gamme(10):
print "'i' est maintenant à " + str(i)

L’équivalent en Hy serait :

(pour [i (plage 10)]
(imprimer (+ "'i' est maintenant à " (str i))))

Vous pouvez également importer et utiliser diverses bibliothèques Python. Par exemple:

(importer le système d'exploitation)

(if (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/anotherdir")
(imprimer "Hé, ce chemin n'est pas là !"))

Les gestionnaires de contexte de Python (avec déclarations) sont utilisées comme ceci :

(avec [[f (open "/tmp/data.in")]]
(imprimer (.lire f)))

ce qui équivaut à:

avec open("/tmp/data.in") comme f :
imprimer f.read()

Et oui, nous avons des compréhensions de liste ! En Python, vous pourriez faire :

cotes_squared = [
pow(num, 2)
pour num dans gamme(100)
si num % 2 == 1]

Dans Hy, vous pouvez faire ceci comme :

(setv cotes au carré
(liste-comp
(pouvoir numéro 2)
(numéro (plage 100))
(= (% num 2) 1)))

; Et, un exemple volé sans vergogne sur une page Clojure :
; Listons tous les blocs d'un échiquier :

(liste-comp
(, xy)
(x (plage 8)
et "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 prend en charge divers arguments sophistiqués et arguments de mots clés. En Python, nous pourrions
voir:

>>> def optionnel_arg(pos1, pos2, mot-clé1=Aucun, mot-clé2=42) :
... retourner [pos1, pos2, mot-clé1, mot-clé2]

>>> option_arg(1, 2)
[1, 2, Aucun, 42]
>>> option_arg(1, 2, 3, 4)
[1, 2, 3, 4]
>>> option_arg(mot-clé1=1, pos2=2, pos1=3, mot-clé2=4)
[3, 2, 1, 4]

La même chose dans Hy :

=> (defn option-arg [pos1 pos2 &optional password1 [keyword2 42]]
... [pos1 pos2 mot-clé1 mot-clé2])
=> (argument-facultatif 1 2)
[1 2 Aucun 42]
=> (argument-facultatif 1 2 3 4)
[1 2 3 4]

Si vous utilisez une version de Hy antérieure à 0.10.1 (par exemple, git master), il existe également une nouvelle version intéressante
Syntaxe de l'argument du mot-clé :

=> (argument-facultatif :mot-clé1 1
... :pos2 2
... :pos1 3
... :mot-clé2 4)
[3, 2, 1, 4]

Sinon, vous pouvez toujours utiliser vous inscrire. Mais qu'est-ce que c'est vous inscrire?

Connaissez-vous le passage *arguments ainsi que ** kwargs en Python ? :

>>> arguments = [1 2]
>>> kwargs = {"mot-clé2": 3
... "mot-clé1": 4}
>>> optionnel_arg(*args, **kwargs)

On peut reproduire cela avec vous inscrire:

=> (arguments setv [1 2])
=> (setv kwargs {"mot-clé2" 3
... "mot-clé1" 4})
=> (appliquer les arguments facultatifs args kwargs)
[1, 2, 4, 3]

Il existe également une construction d'arguments de mots-clés de style dictionnaire qui ressemble à :

(définir un autre style [&key {"key1" "val1" "key2" "val2"}]
[clé1 clé2])

La différence ici est que puisqu'il s'agit d'un dictionnaire, vous ne pouvez pas vous fier à un dictionnaire spécifique.
ordonner les arguments.

Hy prend également en charge *arguments ainsi que ** kwargs. En Python :

def some_func(foo, bar, *args, **kwargs) :
importer une impression
pprint.pprint((foo, bar, arguments, kwargs))

L'équivalent Hy :

(defn some-func [foo bar &rest args &kwargs kwargs]
(importer une impression)
(pprint.pprint (, foo bar arguments kwargs)))

Enfin, bien sûr, nous avons besoin de cours ! En Python, nous pourrions avoir une classe comme :

classe FooBar (objet):
"" "
Encore un autre exemple de classe
"" "
def __init__(soi, x) :
soi.x = x

def get_x(soi) :
"" "
Renvoyez notre copie de x
"" "
retourner soi-même.x

À Hy :

(defclass FooBar [objet]
"Encore un autre exemple de classe"
[[--init--
(fn [moi x]
(setv self.xx)
; Actuellement nécessaire pour --init-- car __init__ n'a besoin d'aucun
; J'espère que cela disparaîtra :)
Aucun)]

[get-x
(fn [soi]
"Renvoyez notre copie de x"
soi.x)]])

Vous pouvez également créer des attributs au niveau de la classe. En Python :

classe Client (models.Model):
name = models.CharField (max_length = 255)
adresse = modèles.TextField()
notes = modèles.TextField()

À Hy :

(client defclass [models.Model]
[[nom (models.CharField : longueur maximale 255})]
[adresse (models.TextField)]
[notes (models.TextField)]])

Hy <-> Python interop
En important Hy, vous pouvez utiliser Hy directement depuis Python !

Si vous enregistrez ce qui suit dans salutations.hy:

(defn saluer [nom] (imprimer "bonjour de hy", nom))

Ensuite, vous pouvez l'utiliser directement depuis python, en important hy avant d'importer le module. Dans
python:

importer hy
importer des salutations

salutations.greet("Foo")

Vous pouvez également déclarer une fonction en python (ou même une classe !) et l'utiliser dans Hy!

Si vous enregistrez ce qui suit dans salutations.py en Python:

def salue(nom):
print("bonjour, %s" % (nom))

Vous pouvez l'utiliser dans Hy :

(importer les salutations)
(.greet salutations "foo")

Pour utiliser des arguments de mots-clés, vous pouvez utiliser dans salutations.py:

def greet(name, title="Monsieur") :
print("Salutations, %s %s" % (titre,nom))

(importer les salutations)
(.greet salutations "Foo")
(.greet salutations "Foo" "Darth")
(appliquer (. salutations saluer) ["Foo"] {"titre" "Seigneur"})

Ce qui produirait:

Salutations, Monsieur Foo

Salutations, Dark Foo

Salutations, Seigneur Foo

Conseils pro !
Hy propose également quelque chose connu sous le nom de « macro de thread », une fonctionnalité très intéressante de
Celui de Clojure. La "macro de thread" (écrite sous la forme ->) est utilisé pour éviter une nidification profonde de
expressions.

La macro de thread insère chaque expression dans le premier argument de l'expression suivante
place.

Prenons le classique :

(boucle (imprimer (évaluer (lire))))

Plutôt que de l’écrire ainsi, on peut l’écrire ainsi :

(-> (lire) (évaluer) (imprimer) (boucle))

Maintenant, en utilisant python-sh, nous pouvons montrer comment la macro de threading (en raison de la configuration de python-sh)
peut être utilisé comme une pipe :

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

Ce qui, bien entendu, s'étend à :

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

Beaucoup plus lisible, non ? Utilisez la macro de threading !

HY STYLE GUIDE

« Vous savez, Monsieur le Ministre, je suis en désaccord avec Dumbledore sur de nombreux points… mais vous ne pouvez pas nier qu'il est
j'ai du style… »- Phineas Nigellus Black, Harry Potier ainsi que le Commander of le Phénix

Le guide de style Hy se veut un ensemble de règles de base pour Hyve (oui, la communauté Hy
se targue d'ajouter Hy à tout) pour écrire du code Hy idiomatique. Hy dérive beaucoup
de Clojure & Common Lisp, tout en conservant toujours l'interopérabilité de Python.

Prélude
La Tao of Hy
Ummon a demandé au moine en chef : « Sur quel sutra enseignez-vous ?
«Le Sutra du Nirvana».
"Le Sutra du Nirvana a les Quatre Vertus, n'est-ce pas ?"
"Il a."
Ummon a demandé en prenant une tasse : « Combien de vertus a-t-il ?
"Aucun du tout", dit le moine.
"Mais les anciens disaient que c'était le cas, n'est-ce pas ?" » dit Ummon.
« Que penses-tu de ce qu'ils ont dit ?
Ummon frappa la coupe et demanda : « Vous comprenez ?
"Non", dit le moine.
"Alors," dit Ummon, "tu ferais mieux de continuer tes conférences sur le sutra."
— la macro (koan)

Ce qui suit illustre une brève liste des décisions de conception qui ont présidé à l'élaboration de
Hy.

· Ressembler à un Lisp ; DTRT avec (par exemple, les tirets se transforment en traits de soulignement, les cache-oreilles se transforment en
toutes en majuscules).

· Nous sommes toujours Python. La plupart des éléments internes traduisent 1:1 en éléments internes Python.

· Utilisez Unicode partout.

· Corrigez les mauvaises décisions dans Python 2 quand nous le pouvons (voir vraie_division).

· En cas de doute, reportez-vous à Python.

· Si vous n'êtes toujours pas sûr, confiez-vous à Clojure.

· Si vous êtes encore plus incertain, reportez-vous à Common Lisp.

· Gardez à l'esprit que nous ne sommes pas Clojure. Nous ne sommes pas Common Lisp. Nous sommes Homoïconic Python, avec
des éléments supplémentaires qui ont du sens.

Disposition & échancrure
· Évitez les espaces de fin. Ils sont nuls !

· L'indentation doit être de 2 espaces (pas de languettes rigides), sauf si elle correspond à l'indentation de
la ligne précédente.

;; Bon (et préféré)
(défn fib [n]
(si (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Toujours bien
(défn fib [n]
(si (<= n 2) n (+ (fib (- n 1)) (fib (- n 2)))))

;; Toujours bien
(défn fib [n]
(si (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Hystériquement ridicule
(défn fib [n]
(si (<= n 2)
n ;; oui, j'aime appuyer au hasard sur la touche espace
(+ (fib (- n 1)) (fib (- n 2)))))

· Les parenthèses doivent n'allons jamais être laissés seuls, tristes et solitaires sur leur propre ligne.

;; Bon (et préféré)
(défn fib [n]
(si (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))))

;; Hystériquement ridicule
(défn fib [n]
(si (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2)))
)
) ; GAH, BRÛLEZ-LE AVEC LE FEU

· Aligner verticalement laisser Blocs.

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

· Les commentaires en ligne doivent être à deux espaces de la fin du code ; ils doivent toujours avoir un
espace entre le caractère de commentaire et le début du commentaire. Essayez également de ne pas
commentez l’évidence.

;; Bien
(setv ind (déc x)) ; l'indexation commence à 0

;; Conforme au style mais énonce simplement l'évidence
(setv ind (déc x)) ; définit l'index sur x-1

;; Mauvais
(setv ind (dec x));taper des mots pour s'amuser

Codage Style
· Par convention, essayez de ne pas utiliser def pour tout autre chose que les variables globales ; utiliser sev
à l'intérieur des fonctions, des boucles, etc.

;; Bon (et préféré)
(déf *limite* 400000)

(défn fibs [ab]
(bien que vrai
(rendement a)
(setv (, ab) (, b (+ ab)))))

;; Mauvais (et non préféré)
(défn fibs [ab]
(bien que vrai
(rendement a)
(déf (, ab) (, b (+ ab)))))

· N'utilisez pas la syntaxe d'expression S là où la syntaxe vectorielle est prévue. Par exemple, le fait
que le premier de ces deux exemples fonctionne simplement parce que le compilateur n'est pas trop
strict. En réalité, la syntaxe correcte dans des endroits comme celui-ci est cette dernière.

;; Mauvais (et méchant)
(défn foo (x) (imprimer x))
(foo1)

;; Bon (et préféré)
(défn foo [x] (imprimer x))
(foo1)

· Utilisez la macro de thread ou les macros de queue de thread lorsque vous rencontrez des problèmes profondément imbriqués.
expressions s. Soyez toutefois judicieux lorsque vous les utilisez. Utilisez-les lorsque la clarté et
la lisibilité s'améliore ; ne construisez pas d’expressions alambiquées et difficiles à comprendre.

;; Préféré
(déf *noms*
(avec [f (ouvrir "names.txt")]
(-> (.read f) (.strip) (.replace "\"" "") (.split ",") (trié))))

;; Pas si bon
(déf *noms*
(avec [f (ouvrir "names.txt")]
(trié (.split "," (.replace "\"" "" (.strip (.read f)))))))

;; Probablement pas une bonne idée
(carré défini ? [x]
(->> 2 (pow (int (sqrt x))) (= x)))

· La notation par points de style Clojure est préférée à l'appel direct de la méthode de l'objet,
même si les deux continueront à être pris en charge.

;; Bien
(avec [fd (ouvrir "/ Etc / passwd")]
(imprimer (.readlines fd)))

;; Pas si bon
(avec [fd (ouvrir "/ Etc / passwd")]
(imprimer (fd.readlines)))

Conclusion
« Les modes passent, le style est éternel » – Yves Saint Laurent

Ce guide n'est qu'un ensemble de directives communautaires, et évidemment, les directives communautaires ne le font pas.
cela n’a aucun sens sans une communauté active. Les contributions sont les bienvenues. Rejoignez-nous à #hy in
freenode, bloguez à ce sujet, tweetez à ce sujet et, surtout, amusez-vous avec Hy.

Merci
· Ce guide est fortement inspiré de @paultag article de blog de Hy Survival Guide

· Le Clojure Style Guide

DOCUMENTATION INDEX

Contenu:

Command Gamme Interfaces
hy
Command Gamme Options
-c
Exécutez le code Hy dans commander.

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

-i
Exécutez le code Hy dans commander, puis restez dans REPL.

-m
Exécutez le code Hy dans module, dont defmain si défini.

La -m L'indicateur termine la liste d'options afin que tous les arguments après le module prénom
sont transmis au module dans sys.argv.

Nouveau dans la version 0.10.2.

--espionner Imprimez le code Python équivalent avant de l'exécuter. Par exemple:

=> (defn salutationsnm [nom] (imprimer (+ "Hy " nom "!")))
def salutationsnm(nom) :
return print(((u'Hy ' + nom) + u'!'))
=> (salutationsnm "VotreNom")
salutationsnm(u'VotreNom')
Salut ton nom !
=>

Nouveau dans la version 0.9.11.

--show-traces
Imprimez des traçages étendus pour les exceptions Hy.

Nouveau dans la version 0.9.12.

-v Imprimez le numéro de version Hy et quittez.

HYC
Command Gamme Options
déposer[, fichierN]
Compilez le code Hy en bytecode Python. Par exemple, enregistrez le code suivant sous
hyname.hy:

(définition hy-hy [nom]
(imprimer (+ "Hy " nom "!")))

(hy-hy "Afroman")

Ensuite, lancez:

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

hy2py
Nouveau dans la version 0.10.1.

Command Gamme Options
-s

--avec-source
Afficher la structure source analysée.

-a

--avec-ast
Afficher l'AST généré.

-np

--sans-python
N'affiche pas le code Python généré à partir de l'AST.

Hy (les Langue)
AVERTISSEMENT:
Ceci est incomplet ; veuillez envisager de contribuer à l'effort de documentation.

THÉORIE of Hy
Hy maintient, par-dessus tout, une compatibilité à 100 % dans les deux sens avec Python
lui-même. Tout le code Hy suit quelques règles simples. Mémorisez ceci, car il va arriver
pratique.

Ces règles permettent de garantir que le code Hy est idiomatique et interfaçable dans les deux langues.

· Les symboles dans les cache-oreilles seront traduits dans la version majuscule de cette chaîne. Pour
Par exemple, foo deviendra FOO.

· Les entités UTF-8 seront codées en utilisant punycode et préfixé par hy_. Par exemple, ⚘
deviendra hy_w7h, ♥ deviendra hy_g6het je♥tu deviendra hy_iu_t0x.

· Les symboles contenant des tirets seront remplacés par des traits de soulignement. Par exemple,
modèle de rendu deviendra modèle_de rendu. Cela signifie que les symboles avec des tirets seront
ombrer leurs équivalents de soulignement, et vice versa.

Built-Ins
Hy propose un certain nombre de formulaires spéciaux qui sont utilisés pour aider à générer un Python AST correct.
Les formulaires suivants sont des formulaires « spéciaux », qui peuvent avoir un comportement légèrement inattendu dans
certaines situations.

.
Nouveau dans la version 0.10.0.

. est utilisé pour effectuer un accès aux attributs sur les objets. Il utilise un petit DSL pour permettre une connexion rapide
accès aux attributs et aux éléments dans une structure de données imbriquée.

Par exemple,

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

Compile jusqu'à :

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

. compile son premier argument (dans l'exemple, foo) comme objet sur lequel effectuer le
déréférencement d'attribut. Il utilise des symboles nus comme attributs d'accès (dans l'exemple, barre,
baz, frob), et compile le contenu des listes (dans l'exemple, [(+ 1 2)]) pour l'indexation.
D'autres arguments génèrent une erreur de compilation.

L'accès à des attributs inconnus génère un Erreur d'attribut. L'accès à des clés inconnues génère un
Erreur d'index (sur les listes et les tuples) ou un Erreur de clé (sur les dictionnaires).

->
-> (Ou l' filetage macro) est utilisé pour éviter l’imbrication des expressions. La macro de thread
insère chaque expression à la première place d'argument de l'expression suivante. Ce qui suit
le code démontre ceci :

=> (sortie définie [ab] (imprimer ab))
=> (-> (+ 4 6) (sortie 5))
+10 (5)XNUMX XNUMX

- >>
- >> (Ou l' filetage queue macro) est similaire à filetage macro, mais au lieu de
en insérant chaque expression dans le premier argument de l'expression suivante, il l'ajoute en tant que
dernier argument. Le code suivant le démontre :

=> (sortie définie [ab] (imprimer ab))
=> (->> (+ 4 6) (sortie 5))
+5 (10)XNUMX XNUMX

vous inscrire
vous inscrire est utilisé pour appliquer une liste facultative d'arguments et un dictionnaire facultatif de kwargs
à une fonction.

Usage: (appliquer nom-fn [arguments] [kwargs])

Exemples :

(je pense vraiment []
"Salut là-bas")

(appliquer la réflexion)
;=> "Salut là-bas"

(achat total défini [montant du prix & facultatif [frais 1.05] [tva 1.1]]
(*prix montant honoraires tva))

(appliquer l'achat total [10 15])
;=> 173.25

(appliquer le total d'achat [10 15] {"vat" 1.05})
;=> 165.375

(appliquer total-achat [] {"prix" 10 "montant" 15 "tva" 1.05})
;=> 165.375

ainsi que
ainsi que est utilisé dans les expressions logiques. Cela prend au moins deux paramètres. Si tous les paramètres
évaluer pour Vrai, le dernier paramètre est renvoyé. Dans tous les autres cas, la première valeur fausse
sera restitué. Exemple d'utilisation :

=> (et Vrai Faux)
Faux

=> (et Vrai Vrai)
Vrai

=> (et Vrai 1)
1

=> (et Vrai [] Faux Vrai)
[]

REMARQUE:
ainsi que court-circuite et arrête d'évaluer les paramètres dès que le premier faux est
rencontré.

=> (et False (imprimer "bonjour"))
Faux

affirmer
affirmer est utilisé pour vérifier les conditions pendant l'exécution du programme. Si la condition n'est pas
rencontré, un Erreur d'assertion est soulevé. affirmer peut prendre un ou deux paramètres. La première
Le paramètre est la condition à vérifier, et il doit être évalué soit Vrai or FauxL’
le deuxième paramètre, facultatif, est une étiquette pour l'assertion et est la chaîne qui sera
élevé avec le Erreur d'assertion. Par exemple:

(affirmer (= valeur attendue variable))

(affirmer faux)
; Erreur d'assertion

(affirmer (= 1 2) "un devrait être égal à deux")
; AssertionError : un doit être égal à deux

Assoc
Assoc est utilisé pour associer une clé à une valeur dans un dictionnaire ou pour définir un index d'une liste
à une valeur. Il faut au moins trois paramètres : le données structure à modifier, un key
or indiceEt un Plus-value. Si plus de trois paramètres sont utilisés, ils seront associés par paires.

Exemples d'utilisation :

=>(laisser [[collection {}]]
... (collection associative "Chien" "Aboiement")
... (collection imprimée))
{u'Dog' : u'Bark'}

=>(laisser [[collection {}]]
... (collection associative "Chien" "Aboiement" "Chat" "Miaou")
... (collection imprimée))
{u'Cat' : u'Meow', u'Dog' : u'Bark'}

=>(laisser [[collection [1 2 3 4]]]
... (collection associée 2 Aucun)
... (collection imprimée))
[1, 2, Aucun, 4]

REMARQUE:
Assoc modifie la structure de données en place et renvoie Aucun.

pause
pause est utilisé pour sortir d'une boucle. Il termine immédiatement la boucle. Ce qui suit
l'exemple a un infini tout en boucle qui se termine dès que l'utilisateur entre k.

(tandis que True (if (= "k" (entrée brute "? "))
(casser)
(imprimer "Réessayer")))

cond
cond peut être utilisé pour construire des if déclarations. L'exemple suivant montre le
relation entre la macro et son expansion :

(cond [condition-1 résultat-1]
[condition-2 résultat-2])

(si condition-1 résultat-1
(si condition-2 résultat-2))

Comme indiqué ci-dessous, seul le premier bloc de résultats correspondant est exécuté.

=> (valeur de contrôle définie [valeur]
... (cond [(< valeur 5) (imprimer "la valeur est inférieure à 5")]
... [(= valeur 5) (imprimer "la valeur est égale à 5")]
... [(> valeur 5) (imprimer "la valeur est supérieure à 5")]
... [Vrai (imprimer "la valeur est quelque chose qu'elle ne devrait pas être")]))

=> (valeur de contrôle 6)
la valeur est supérieure à 5

continuer
continuer renvoie l'exécution au début d'une boucle. Dans l'exemple suivant,
(effet secondaire1) est appelé à chaque itération. (effet secondaire2), cependant, n'est sollicité que
toutes les autres valeurs de la liste.

;; en supposant que (side-effect1) et (side-effect2) sont des fonctions et
;; la collection est une liste de valeurs numériques

(pour [x collection]
(de
(effet secondaire1 x)
(si (% x 2)
(continuer))
(effet secondaire2 x)))

dict-comp
dict-comp est utilisé pour créer des dictionnaires. Cela prend trois ou quatre paramètres. La première
deux paramètres servent à contrôler la valeur de retour (paire clé-valeur) tandis que le troisième est
utilisé pour sélectionner des éléments dans une séquence. Le quatrième paramètre, facultatif, peut être utilisé pour
filtrer certains éléments de la séquence en fonction d'une expression conditionnelle.

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

do / prog
do ainsi que prog sont utilisés pour évaluer chacun de leurs arguments et renvoyer le dernier. Retour
les valeurs de tous les arguments autres que le dernier sont ignorées. Il peut être utilisé dans lambda or
liste-comp pour exécuter une logique plus complexe, comme le montre l'un des exemples suivants.

Quelques exemples d'utilisation :

=> (si vrai
... (faire (imprimer "Side Effects Rock!")
... (imprimer "Ouais, vraiment!")))
Les effets secondaires sont rock !
Ouais vraiment!

;; en supposant que (effet secondaire) est une fonction que nous voulons appeler pour chaque
;; et chaque valeur de la liste, mais dont la valeur de retour ne nous intéresse pas
=> (list-comp (do (effet secondaire x)
... (si (< x 5) (* 2 x)
... (* 4x)))
... (x (plage 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do peut accepter n'importe quel nombre d'arguments, de 1 à n.

def / sev
def ainsi que sev sont utilisés pour lier une valeur, un objet ou une fonction à un symbole. Par exemple:

=> (noms définis ["Alice" "Bob" "Charlie"])
=> (imprimer les noms)
[u'Alice', u'Bob', u'Charlie']

=> (compteur setv (fn [élément de collection] (élément de collection .count)))
=> (compteur [1 2 3 4 5 2 3] 2)
2

classe déf
Les nouvelles classes sont déclarées avec classe déf. Il peut prendre deux paramètres optionnels : un vecteur
définir une éventuelle super classes et un autre vecteur contenant les attributs du nouveau
classer comme deux vecteurs d’éléments.

(nom-classe defclass [super-class-1 super-class-2]
[[valeur d'attribut]])

Les valeurs et les fonctions peuvent être liées à la nouvelle classe, comme le montre l'exemple ci-dessous :

=> (classe def Chat []
... [[âge Aucun]
... [couleur "blanc"]
... [parler (fn [soi] (imprimer "Miaou"))]])

=> (déf spot (Cat))
=> (setv spot.couleur "Noir")
'Noir'
=> (.speak spot)
Miaou

défn / défun
défn ainsi que défun les macros sont utilisées pour définir des fonctions. Ils prennent trois paramètres : le prénom
de la fonction à définir, un vecteur de paramètres, et le corps de la fonction :

(corps du nom défini [params])

Les paramètres peuvent être précédés des mots-clés suivants :

&facultatif
Le paramètre est facultatif. Le paramètre peut être donné sous la forme d'une liste de deux éléments, où le
le premier élément est le nom du paramètre et le second est la valeur par défaut. Le paramètre
peut également être donné comme un seul élément, auquel cas la valeur par défaut est Aucun.

=> (valeur totale définie [valeur &facultatif [taxe sur la valeur ajoutée 10]]
... (+ (/ (* valeur taxe sur la valeur ajoutée) 100) valeur))

=> (valeur totale 100)
110.0

=> (valeur totale 100 1)
101.0

&clé

&kwargs
Le paramètre contiendra 0 ou plusieurs arguments de mot-clé.

Les exemples de code suivants définissent une fonction qui imprimera tous les mots-clés
arguments et leurs valeurs.

=> (paramètres d'impression définis [&kwargs kwargs]
... (pour [(, kv) (.items kwargs)] (imprimer kv)))

=> (appliquer les paramètres d'impression [] {"paramètre-1" 1 "paramètre-2" 2})
paramètre-2 2
paramètre-1 1

&repos Le paramètre contiendra 0 ou plusieurs arguments de position. Aucun autre poste
des arguments peuvent être spécifiés après celui-ci.

L'exemple de code suivant définit une fonction qui peut recevoir de 0 à n valeurs numériques
paramètres. Il additionne ensuite tous les nombres impairs et soustrait tous les nombres pairs.

=> (somme en zigzag définie [&numéros de repos]
(soit [[nombres impairs (list-comp x [x nombres] (impair ? x))]
[nombres pairs (list-comp x [x nombres] (pair ? x))]]
(- (somme des nombres impairs) (somme des nombres pairs))))

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

alias défn / alias defun
Nouveau dans la version 0.10.0.

La alias défn ainsi que alias defun les macros ressemblent beaucoup défn, avec la distinction que
au lieu de définir une fonction avec un seul nom, ceux-ci peuvent également définir des alias. Autre
que de prendre une liste de symboles pour les noms de fonctions comme premier paramètre, alias défn ainsi que
alias defun ne sont pas différents de défn ainsi que défun.

=> (defn-alias [alias du nom principal] []
... (imprimer "Bonjour !"))
=> (nom principal)
"Bonjour!"
=> (alias)
"Bonjour!"

defmain
Nouveau dans la version 0.10.1.

La defmain macro définit une fonction principale qui est immédiatement appelée avec sys.argv as
arguments si et seulement si ce fichier est exécuté en tant que script. En d'autres termes, ceci :

(defmain [&rest arguments]
(faire quelque chose avec les arguments))

est l'équivalent de :

def principal(*arguments) :
faire_quelque chose_avec(arguments)
retour 0

if __name__ == "__main__":
système d'importation
retval = principal(*sys.arg)

si estinstance (retval, int):
sys.exit (retval)

Notez que comme vous pouvez le voir ci-dessus, si vous renvoyez un entier depuis cette fonction, ce sera
utilisé comme état de sortie pour votre script. (Python par défaut quitte le statut 0 sinon,
ce qui veut dire que tout va bien !)

(Depuis (sys.exit 0) n'est pas exécuté explicitement dans le cas d'un retour non entier de
defmain, c'est une bonne idée de mettre (défmain) comme dernier morceau de code de votre fichier.)

défmacro
défmacro est utilisé pour définir des macros. Le format général est (défmacro prénom [paramètres]
expression).

L'exemple suivant définit une macro qui peut être utilisée pour permuter l'ordre des éléments dans le code,
permettant à l'utilisateur d'écrire du code en notation infixe, où l'opérateur est entre les
opérandes.

=> (infixe defmacro [code]
... (quasi-citation (
... (unquote (obtenir le code 1))
... (unquote (obtenir le code 0))
... (unquote (obtenir le code 2)))))

=> (infixe (1 + 1))
2

defmacro-alias
defmacro-alias est utilisé pour définir des macros avec plusieurs noms (alias). Le format général
is (defmacro-alias [noms] [paramètres] expression). Il crée plusieurs macros avec le même
liste de paramètres et corps, sous la liste de noms spécifiée.

L'exemple suivant définit deux macros, qui permettent toutes deux à l'utilisateur d'écrire du code dans
notation infixe.

=> (defmacro-alias [infixe infi] [code]
... (quasi-citation (
... (unquote (obtenir le code 1))
... (unquote (obtenir le code 0))
... (unquote (obtenir le code 2)))))

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

defmacro/g!
Nouveau dans la version 0.9.12.

defmacro/g! est une version spéciale de défmacro qui est utilisé pour générer automatiquement gensyme
pour tout symbole commençant par g!.

Par exemple, Géorgie deviendrait (gensym "un").

VOIR AUSSI:
Section utilisant-gensym

défreader
Nouveau dans la version 0.9.12.

défreader définit une macro de lecture, permettant de restructurer ou de modifier la syntaxe.

=> (defreader ^ [expr] (impression expr))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Bonjour"
"Bonjour"

VOIR AUSSI:
Macros du lecteur de section

de la
Nouveau dans la version 0.9.12.

de la supprime un objet de l'espace de noms actuel.

=> (setv foo 42)
=> (supprimer foo)
=> foo
Traceback (appel le plus récent dernier):
Déposer " ", ligne 1, dans
NameError : le nom 'foo' n'est pas défini

de la peut également supprimer des objets des mappages, des listes, etc.

=> (setv test (liste (plage 10)))
=> tester
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (del (slice test 2 4)) ;; supprimer les éléments de 2 à 4 exclus
=> tester
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "bar"})
=> dic
{"foo": "barre"}
=> (del (obtenir dic "foo"))
=> dic
{}

à faire
Nouveau dans la version 0.10.1.

à faire est utilisé pour simplifier une séquence d’appels de méthode à un objet.

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

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

eval
eval évalue une expression entre guillemets et renvoie la valeur.

=> (eval '(imprimer "Hello World"))
"Bonjour le monde"

évaluer et compiler
évaluer lors de la compilation
premier / fournisseur
premier ainsi que fournisseur sont des macros permettant d'accéder au premier élément d'une collection :

=> (premier (plage 10))
0

en
en est utilisé pour appeler une fonction pour chaque élément d'une liste ou d'un vecteur. Les résultats de chacun
l'appel est rejeté et le en l'expression renvoie Aucun plutôt. L'exemple de code itère
plus de collection et pour chacun élément in collection appelle le effet secondaire fonctionner avec
élément comme argument :

;; en supposant que (effet secondaire) est une fonction qui prend un seul paramètre
(pour [collection d'éléments] (élément à effet secondaire))

;; for peut avoir un bloc else facultatif
(pour [collection d'éléments] (élément à effet secondaire)
(sinon (effet secondaire-2)))

Le facultatif d'autre Le bloc n'est exécuté que si le en la boucle se termine normalement. Si la
l'exécution est interrompue avec pause, d'autre le bloc ne s’exécute pas.

=> (pour [élément [1 2 3]] (si (< élément 3)
... (élément d'impression)
... (casser))
... (sinon (imprimer "boucle terminée")))
1
2

=> (pour [élément [1 2 3]] (si (< élément 4)
... (élément d'impression)
... (casser))
... (sinon (imprimer "boucle terminée")))
1
2
3
boucle terminée

genexpr
genexpr est utilisé pour créer des expressions génératrices. Cela prend deux ou trois paramètres. Le
le premier paramètre est l'expression contrôlant la valeur de retour, tandis que le second est utilisé
pour sélectionner des éléments dans une liste. Le troisième paramètre facultatif peut être utilisé pour filtrer
certains des éléments de la liste en fonction d'une expression conditionnelle. genexpr est similaire à
liste-comp, sauf qu'il renvoie un itérable qui évalue les valeurs une par une au lieu de
les évaluer immédiatement.

=> (collection def (plage 10))
=> (filtré par défaut (genexpr x [x collection] (pair ? x)))
=> (liste filtrée)
[0, 2, 4, 6, 8]

gensyme
Nouveau dans la version 0.9.12.

gensyme est utilisé pour générer un symbole unique qui permet d'écrire des macros sans
conflits accidentels de noms de variables.

=> (gensym)
vous':G_1235'

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

VOIR AUSSI:
Section utilisant-gensym

obtenez
obtenez est utilisé pour accéder à des éléments uniques dans des listes et des dictionnaires. obtenez prend deux paramètres :
le données structure et par indice or key de l'article. Il renverra ensuite le correspondant
valeur du dictionnaire ou de la liste. Exemple d'utilisation :

=> (laisser [[animaux {"chien" "écorce" "chat" "miaou"}]
... [nombres ["zéro" "un" "deux" "trois"]]]
... (imprimer (obtenir des animaux "chien"))
... (imprimer (obtenir les numéros 2)))
écorce
deux

REMARQUE:
obtenez déclenche une KeyError si un dictionnaire est interrogé pour une clé inexistante.

REMARQUE:
obtenez déclenche une IndexError si une liste ou un tuple est interrogé pour un index qui est hors de
bornes.

de défis
de défis peut être utilisé pour marquer un symbole comme global. Cela permet au programmeur d'attribuer un
valeur à un symbole global. La lecture d'un symbole global ne nécessite pas le de défis mot-clé --
seule l'attribution le fait.

L'exemple suivant montre comment le symbole global a se voit attribuer une valeur dans une fonction et
est imprimé plus tard dans une autre fonction. Sans le de défis mot-clé, la deuxième fonction
aurait jeté un NomErreur.

(définition set-a [valeur]
(global a)
(définir une valeur))

(définition print-a []
(imprimer a))

(set-un 5)
(imprimer-a)

if / sinon
Nouveau dans la version 0.10.0 : si-non

if est utilisé pour sélectionner conditionnellement le code à exécuter. Il doit contenir une condition
bloc et le bloc à exécuter si le bloc de condition est évalué à Vrai. En option,
il peut contenir un bloc final qui est exécuté au cas où l'évaluation de la condition est
Faux.

sinon est similaire, mais le deuxième bloc sera exécuté lorsque la condition échoue alors que
le troisième et dernier bloc est exécuté lorsque le test réussit -- l'ordre inverse de if.

Exemple d'utilisation:

(si (il reste de l'argent ? compte)
(imprimer "allons faire du shopping")
(imprimer "allons travailler"))

(sinon (il reste de l'argent ? compte)
(imprimer "allons travailler")
(imprimer "allons faire du shopping"))

La véracité de Python est respectée. Aucun, Faux, zéro de n'importe quel type numérique, une séquence vide,
et un dictionnaire vide sont considérés Faux; tout le reste est pris en compte Vrai.

lisp-si / lif ainsi que zézayer si ce n'est pas le cas / si-pas
Nouveau dans la version 0.10.0.

Nouveau dans la version 0.10.2 : lisp-if-not / lif-not

Pour ceux qui préfèrent un plus Lispy if clause, nous avons lisp-siou lif. Ce uniquement considère
Aucun / nul être faux ! Toutes les autres valeurs Python « fausses » sont considérées comme vraies.
A l’inverse, nous avons zézayer si ce n'est pas le cas ainsi que si-pas en parallèle de if ainsi que sinon qui inverse
La comparaison.

=> (lisp-if True "vrai" "faux")
"True"
=> (lisp-if Faux "vrai" "faux")
"True"
=> (lisp-si 0 "vrai" "faux")
"True"
=> (lisp-si nul "vrai" "faux")
"faux"
=> (lisp-if Aucun "vrai" "faux")
"faux"
=> (lisp-if-not nil "vrai" "faux")
"True"
=> (lisp-if-not Aucun "vrai" "faux")
"True"
=> (lisp-if-not Faux "vrai" "faux")
"faux"

; Equivalent mais plus court
=> (lif Vrai "vrai" "faux")
"True"
=> (lif nul "vrai" "faux")
"faux"
=> (lif-not Aucun "vrai" "faux")
"True"

importer
importer est utilisé pour importer des modules, comme en Python. Il existe plusieurs façons de importer vous
être utilisé.

;; Importe chacun de ces modules
;;
;; Python:
;; système d'importation
;; importer os.path
(importer sys os.path)

;; Importer depuis un module
;;
;; Python : depuis os.path, l'importation existe, isdir, isfile
(importer [os.path [existe isdir isfile]])

;; Importer avec un alias
;;
;; Python : importer le système en tant que système
(importer [sys :as systest])

;; Vous pouvez lister autant d’importations que vous le souhaitez de différents types.
(importer [tests.resources [fonction kwtest avec tiret]]
[os.path [existe dans isdir isfile]]
[sys :comme système])

;; Importer toutes les fonctions du module dans l'espace de noms actuel
(importer [sys [*]])

lambda / fn
lambda ainsi que fn peut être utilisé pour définir une fonction anonyme. Les paramètres sont similaires à
défn: le premier paramètre est vecteur de paramètres et le reste est le corps du
la fonction. lambda renvoie une nouvelle fonction. Dans l'exemple suivant, une fonction anonyme
est défini et transmis à une autre fonction pour filtrer la sortie.

=> (définition personnes [{:name "Alice" :age 20}
... {:nom "Bob" :âge 25}
... {:nom "Charlie" :âge 50}
... {:nom "Dave" :âge 5}])

=> (defn display-people [filtre de personnes]
... (pour [personne personnes] (if (filtrer la personne) (imprimer (:nom de la personne)))))

=> (afficher-personnes personnes (fn [personne] (< (:age person) 25)))
Alice
Dave

Tout comme dans les définitions de fonctions normales, si le premier élément du corps est une chaîne, il
sert de docstring. Ceci est utile pour donner des docstrings aux méthodes de classe.

=> (setv fois-trois
... (fn[x]
... "Multiplie l'entrée par trois et renvoie le résultat."
... (*x3)))

Cela peut être confirmé via le module intégré de Python aider fonction:

=> (aide fois-trois)
Aide sur la fonction times_trois :

fois_trois(x)
Multiplie l'entrée par trois et renvoie le résultat
(FIN)

dernier
Nouveau dans la version 0.10.2.

dernier peut être utilisé pour accéder au dernier élément d’une collection :

=> (dernier [2 4 6])
6

laisser
laisser est utilisé pour créer des variables de portée lexicale. Ils sont créés au début du
laisser forme et cessent d’exister après la forme. L'exemple suivant illustre cela
comportement:

=> (soit [[x 5]] (imprimer x)
... (laisser [[x 6]] (imprimer x))
... (imprimer x))
5
6
5

La laisser la macro prend deux paramètres : un vecteur définissant les variables et par corps qui obtient
réalisé. les variables est un vecteur où chaque élément est soit une variable unique, soit un vecteur
définir une paire de valeurs variables. Dans le cas d'une seule variable, on lui attribue une valeur
Aucun; sinon, la valeur fournie est utilisée.

=> (soit [x [y 5]] (imprimer xy))
Aucun 5

liste-comp
liste-comp effectue des compréhensions de listes. Cela prend deux ou trois paramètres. La première
Le paramètre est l'expression contrôlant la valeur de retour, tandis que le second est utilisé pour
sélectionner des éléments dans une liste. Le troisième paramètre facultatif peut être utilisé pour filtrer certains
des éléments de la liste en fonction d'une expression conditionnelle. Quelques exemples:

=> (collection def (plage 10))
=> (liste-comp x [x collection])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

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

ne sauraient
ne sauraient est utilisé dans les expressions logiques. Il prend un seul paramètre et renvoie un inversé
valeur de vérité. Si Vrai est donné en paramètre, Faux sera restitué, et vice versa.
Exemple d'utilisation:

=> (pas vrai)
Faux

=> (pas faux)
Vrai

=> (pas Aucun)
Vrai

or
or est utilisé dans les expressions logiques. Cela prend au moins deux paramètres. Il renverra le
premier paramètre non faux. Si aucune valeur de ce type n’existe, le dernier paramètre sera renvoyé.

=> (ou Vrai Faux)
Vrai

=> (et Faux Faux)
Faux

=> (et Faux 1 Vrai Faux)
1

REMARQUE:
or court-circuite et arrête d'évaluer les paramètres dès que la première valeur vraie est
rencontré.

=> (ou True (imprimer "bonjour"))
Vrai

impression
impression est utilisé pour afficher à l’écran. Exemple d'utilisation :

(imprimer "Bonjour tout le monde !")

REMARQUE:
impression revient toujours Aucun.

quasi-citation
quasi-citation vous permet de citer un formulaire, mais aussi d'évaluer sélectivement des expressions.
Expressions à l'intérieur d'un quasi-citation peut être évalué de manière sélective en utilisant fin de citation (~). La
le formulaire évalué peut également être épissé en utilisant sans guillemets-épissure (~@). Quasiquote peut être aussi
écrit en utilisant la citation arrière (`) symbole.

;; soit `qux' une variable avec une valeur (bar baz)
`(foo ~qux)
; équivalent à '(foo (bar baz))
`(foo ~@qux)
; équivalent à '(foo bar baz)

Devis
Devis renvoie le formulaire qui lui est transmis sans l'évaluer. Devis peut alternativement être
écrit en utilisant l'apostrophe (') symbole.

=> (setv x '(imprimer "Hello World"))
; la variable x est définie sur expression et n'est pas évaluée
=>x
(tu'imprimes' tu'Hello World')
=> (évaluation x)
Bonjour tout le monde

exigent
exigent est utilisé pour importer des macros à partir d’un module donné. Il faut au moins un paramètre
spécifiant au module quelles macros doivent être importées. Plusieurs modules peuvent être importés
avec un seul exigent.

L'exemple suivant importera des macros depuis module 1 ainsi que module 2:

(nécessite le module-1 module-2)

reste / cdr
reste ainsi que cdr renvoie la collection passée en argument sans le premier élément :

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

ensemble-comp
ensemble-comp est utilisé pour créer des ensembles. Cela prend deux ou trois paramètres. Le premier paramètre est
pour contrôler la valeur de retour, tandis que le second est utilisé pour sélectionner des éléments dans un
séquence. Le troisième paramètre, facultatif, peut être utilisé pour filtrer certains éléments de
la séquence basée sur une expression conditionnelle.

=> (données setv [1 2 3 4 5 2 3 4 5 3 4 5])
=> (set-comp x [x données] (impair ? x))
{1, 3, 5}

tranche
tranche peut être utilisé pour prendre un sous-ensemble d’une liste et en créer une nouvelle. La forme
prend au moins un paramètre spécifiant la liste à découper. Deux paramètres facultatifs peuvent être
utilisé pour donner la position de début et de fin du sous-ensemble. S'ils ne sont pas fournis, le
valeur par défaut de Aucun sera utilisé à la place. Le troisième paramètre facultatif est utilisé pour
étape de contrôle entre les éléments.

tranche suit les mêmes règles que son homologue Python. Les indices négatifs sont comptés
en commençant par la fin de la liste. Quelques exemples d'utilisation :

=> (collection def (plage 10))

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

=> (collection de tranches 5)
[5, 6, 7, 8, 9]

=> (collection de tranches 2 8)
[2, 3, 4, 5, 6, 7]

=> (collection de tranches 2 8 2)
[2, 4, 6]

=> (collection de tranches -4 -2)
[6, 7]

renversement / augmenter
La renversement or augmenter les formulaires peuvent être utilisés pour soulever une Exception lors de l'exécution. Exemple d'utilisation :

(lancer)
; re-raser la dernière exception

(lancer IOError)
; Lancer une erreur IOError

(lancer (IOError "foobar"))
; Lancez une IOError("foobar")

renversement peut accepter un seul argument (un Exception classe ou instance) ou aucun argument pour
sur-relancer le dernier Exception.

Essai
La Essai le formulaire est utilisé pour démarrer un Essai / capture bloc. Le formulaire s'utilise de la manière suivante :

(essayer
(fonction sujette aux erreurs)
(attrapez [e ZeroDivisionError] (imprimez "Division par zéro"))
(sinon (imprimer "pas d'erreurs"))
(enfin (imprimer "tout est fait")))

Essai doit contenir au moins un capture bloc, et peut éventuellement inclure un d'autre or enfin
bloc. Si une erreur est générée avec un bloc catch correspondant lors de l'exécution de
fonction sujette aux erreurs, Que capture Le bloc sera exécuté. Si aucune erreur n'est générée, le d'autre
Le bloc est exécuté. Le enfin le bloc sera exécuté en dernier, qu'un bloc soit ou non exécuté.
une erreur a été soulevée.

à moins que
La à moins que macro est un raccourci pour écrire un if instruction qui vérifie si le donné
conditionnel est Faux. Ce qui suit montre l’expansion de cette macro.

(sauf déclaration conditionnelle)

(si conditionnel
Aucun
(faire la déclaration))

fin de citation
Dans une forme quasi-citée, fin de citation force l’évaluation d’un symbole. fin de citation est alias
le tilde (~) symbole.

(nom par définition "Câlins")
(quasiquote (= nom (sans guillemets nom)))
;=> (u'='u'nom' u'Cuddles')

`(= nom ~nom)
;=> (u'='u'nom' u'Cuddles')

sans guillemets-épissure
sans guillemets-épissure force l'évaluation d'un symbole dans une forme quasi-citée, un peu comme
fin de citation. sans guillemets-épissure ne peut être utilisé que lorsque le symbole non cité contient un
valeur itérable, car elle "épisse" cet itérable dans la forme quasi-citée. sans guillemets-épissure is
alias le ~@ symbole.

(numéros par définition [1 2 3 4])
(quasiquote (+ (unquote-splice nums)))
;=> (u'+' 1L 2L 3L 4L)

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

quand
quand est similaire à à moins que, sauf qu'il teste lorsque la condition donnée est Vrai. Ce n'est pas
possible d'avoir un d'autre bloquer dans un quand macro. Ce qui suit montre l'expansion du
macro.

(quand instruction conditionnelle)

(si conditionnel (instruction do))

tout en
tout en est utilisé pour exécuter un ou plusieurs blocs tant qu’une condition est remplie. Ce qui suit
L'exemple affichera "Bonjour tout le monde !" à l'écran indéfiniment :

(tandis que True (imprimez "Bonjour tout le monde !"))

avec
avec est utilisé pour encapsuler l’exécution d’un bloc dans un gestionnaire de contexte. Le contexte
Le gestionnaire peut alors configurer le système local et le démolir de manière contrôlée. Le
exemple archétypique d'utilisation avec c'est lors du traitement des fichiers. avec peut lier le contexte à un
argument ou ignorez-le complètement, comme indiqué ci-dessous :

(avec le bloc [[arg (expr)]])

(avec le bloc [[(expr)]])

(avec le bloc [[arg (expr)] [(expr)]]

L'exemple suivant ouvrira le NOUVELLES fichier et imprimer son contenu à l’écran. Le
Le fichier est automatiquement fermé après son traitement.

(avec [[f (open "NEWS")]] (imprimer (.read f)))

avec-décorateur
avec-décorateur est utilisé pour envelopper une fonction avec une autre. La fonction effectuant le
decoration doit accepter une seule valeur : la fonction en cours de décoration, et renvoyer une nouvelle
la fonction. avec-décorateur prend au minimum deux paramètres : la fonction effectuant
la décoration et la fonction à décorer. Plusieurs fonctions de décorateur peuvent être
appliqué; ils seront appliqués dans l'ordre du plus extérieur au plus intérieur, c'est-à-dire. la première
le décorateur sera le plus extérieur, et ainsi de suite. Les décorateurs avec des arguments sont appelés simplement
comme un appel de fonction.

(avec-décorateur décorateur-amusant
(définir une fonction [] ...)

(avec-décorateur décorateur1 décorateur2 ...
(définir une fonction [] ...)

(avec-décorateur (décorateur arg) ..
(définir une fonction [] ...)

Dans l'exemple suivant, inc-décorateur est utilisé pour décorer la fonction ajout avec une
fonction qui prend deux paramètres et appelle la fonction décorée avec des valeurs qui sont
incrémenté de 1. Lorsque le décoré ajout est appelé avec les valeurs 1 et 1, la fin
le résultat sera 4 (1 + 1 + 1 + 1).

=> (defn inc-décorateur [func]
... (fn [valeur-1 valeur-2] (func (+ valeur-1 1) (+ valeur-2 1))))
=> (définition inc2-décorateur [func]
... (fn [valeur-1 valeur-2] (func (+ valeur-1 2) (+ valeur-2 2))))

=> (avec-décorateur inc-décorateur (ajout defn [a b] (+ a b)))
=> (ajout 1 1)
4
=> (avec-décorateur inc2-décorateur inc-décorateur
... (ajout de définition [a b] (+ a b)))
=> (ajout 1 1)
8

avec-gensyms
Nouveau dans la version 0.9.12.

avec-gensym est utilisé pour générer un ensemble de gensyme à utiliser dans une macro. Le code suivant :

(avec-gensyms [a b c]
...)

s'étend à :

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

VOIR AUSSI:
Section utilisant-gensym

rendement
rendement est utilisé pour créer un objet générateur qui renvoie une ou plusieurs valeurs. Le générateur
est itérable et peut donc être utilisé dans des boucles, des compréhensions de listes et autres
construit.

La fonction nombres aléatoires montre comment les générateurs peuvent être utilisés pour générer des séries infinies
sans consommer une quantité infinie de mémoire.

=> (defn multiplier [coefficients de base]
... (pour [[(, coefficient de base) (coefficients de bases zip)]]
... (rendement (* coefficient de base))))

=> (multiplier (plage 5) (plage 5))


=> (list-comp value [valeur (multiplier (plage 10) (plage 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (importation aléatoire)
=> (définition de nombres aléatoires [faible haut]
... (tandis que True (rendement (.randint aléatoire faible haut))))
=> (list-comp x [x (prendre 15 (nombres aléatoires 1 50))])])
[7, 41, 6, 22, 32, 17, 5, 38, 18, 38, 17, 14, 23, 23, 19]

rendement de
Nouveau dans la version 0.9.13.

PYTHON 3.3 ET UP SEULEMENT!

rendement de est utilisé pour appeler un sous-générateur. Ceci est utile si vous souhaitez que votre coroutine
être capable de déléguer ses processus à une autre coroutine, par exemple, si vous utilisez quelque chose de sophistiqué comme
asynchrone.

Hy Core
Core Les fonctions
mais enfin
Usage: (mais en dernier coll)

Renvoie un itérateur de tous les éléments sauf le dernier coll.

=> (liste (jusqu'au dernier (plage 10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8]

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

=> (liste (avantdernier []))
[]

=> (importer itertools)
=> (liste (prendre 5 (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

coll?
Nouveau dans la version 0.10.0.

Usage: (coll? x)

Retours Vrai if x est itérable et non une chaîne.

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

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

=> (coll? "abc")
Faux

contre
Nouveau dans la version 0.10.0.

Usage: (les inconvénients a b)

Renvoie une nouvelle cellule contre avec voiture a et cdr b.

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

=> (= 'hd (voiture a))
Vrai

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

les inconvénients?
Nouveau dans la version 0.10.0.

Usage: (les inconvénients? fou)

Vérifie si foo est une contre-cellule.

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

=> (contre ? a)
Vrai

=> (contre ? nul)
Faux

=> (contre ? [1 2 3])
Faux

déc
Usage: (déc x)

Renvoie un de moins que x. Équivalent à (- x 1). Augmente Erreur-type if (Vous n'êtes pas (numérique ? X)).

=> (3 décembre)
2

=> (0 décembre)
-1

=> (12.3 décembre)
11.3

démonter
Nouveau dans la version 0.10.0.

Usage: (démonter arbre &facultatif [codegen FAUX])

Vider le Python AST pour Hy donné arbre à la sortie standard. Si codegen is Vrai, la fonction
imprime le code Python à la place.

=> (démonter '(imprimer "Hello World!"))
Module(
corps=[
Expr(value=Call(func=Name(id='print'), args=[Str(s='Hello World!')], mots-clés=[], starargs=None, kwargs=None))])

=> (démonter '(imprimer "Hello World!") vrai)
print('Bonjour tout le monde !')

vider?
Usage: (vide? coll)

Retours Vrai if coll est vide. Équivalent à (= 0 (len coll)).

=> (vide ? [])
Vrai

=> (vide ? "")
Vrai

=> (vide ? (, 1 2))
Faux

chaque?
Nouveau dans la version 0.10.0.

Usage: (chaque? pred coll)

Retours Vrai if (préd x) est logiquement vrai pour chaque x in coll, Autrement Faux. Revenir Vrai
if coll est vide.

=> (tous les ? pairs ? [2 4 6])
Vrai

=> (tous les ? pairs ? [1 3 5])
Faux

=> (tous les ? pairs ? [2 4 5])
Faux

=> (tous les ? pairs ? [])
Vrai

flotter?
Usage: (flotter? x)

Retours Vrai if x est un flotteur.

=> (flotteur ? 3.2)
Vrai

=> (flotteur ? -2)
Faux

même?
Usage: (même? x)

Retours Vrai if x est même. Augmente Erreur-type if (Vous n'êtes pas (numérique ? X)).

=> (pair ? 2)
Vrai

=> (pair ? 13)
Faux

=> (pair ? 0)
Vrai

identité
Usage: (identité x)

Renvoie l'argument fourni à la fonction.

=> (identité 4)
4

=> (liste (identité de la carte [1 2 3 4]))
[1 2 3 4]

inc
Usage: (incluant x)

Renvoie un de plus que x. Équivalent à (+ x 1). Augmente Erreur-type if (Vous n'êtes pas (numérique ? X)).

=> (dont 3)
4

=> (dont 0)
1

=> (dont 12.3)
13.3

exemple?
Usage: (exemple? classe x)

Retours Vrai if x est une instance de classe.

=> (instance ? float 1.0)
Vrai

=> (instance ? int 7)
Vrai

=> (instance ? str (str "foo"))
Vrai

=> (defclass TestClass [objet])
=> (setv inst (TestClass))
=> (instance ? TestClass inst)
Vrai

entier?
Usage: (entier? x)

Retours Vrai if x est un entier. Pour Python 2, c'est soit int or Long. Pour Python 3,
c'est int.

=> (entier ? 3)
Vrai

=> (entier ? -2.4)
Faux

entrelacer
Nouveau dans la version 0.10.1.

Usage: (entrelacé suite1 suite2 ...)

Renvoie un itérable du premier élément de chacune des séquences, puis du second, etc.

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

=> (liste (entrelacement (plage 1000000) "abc"))
[0, 'a', 1, 'b', 2, 'c']

interposer
Nouveau dans la version 0.10.1.

Usage: (interposer questions d'examen suite)

Renvoie un itérable des éléments de la séquence séparés par l'élément.

=> (liste (interposer "!" "abcd"))
['a B c d']

=> (liste (interpose -1 (plage 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

itérable ?
Usage: (itérable ? x)

Retours Vrai if x est itérable. Les objets itérables renvoient un nouvel itérateur lorsque (iter x) is
appelé. Contraste avec itérateur ?.

=> ;; fonctionne pour les cordes
=> (itérable ? (str "abcde"))
Vrai

=> ;; fonctionne pour les listes
=> (itérable ? [1 2 3 4 5])
Vrai

=> ;; fonctionne pour les tuples
=> (itérable ? (, 1 2 3))
Vrai

=> ;; fonctionne pour les dictées
=> (itérable ? {:a 1 :b 2 :c 3})
Vrai

=> ;; fonctionne pour les itérateurs/générateurs
=> (itérable ? (répéter 3))
Vrai

itérateur ?
Usage: (itérateur ? x)

Retours Vrai if x est un itérateur. Les itérateurs sont des objets qui se renvoient eux-mêmes sous la forme d'un
itérateur quand (iter x) est appelé. Contraste avec itérable ?.

=> ;; ne fonctionne pas pour une liste
=> (itérateur ? [1 2 3 4 5])
Faux

=> ;; mais nous pouvons obtenir un iter dans la liste
=> (itérateur ? (iter [1 2 3 4 5]))
Vrai

=> ;; ne fonctionne pas pour dict
=> (itérateur? {:a 1 :b 2 :c 3})
Faux

=> ;; créer un itérateur à partir du dict
=> (itérateur ? (iter {:a 1 :b 2 :c 3}))
Vrai

liste*
Usage: (liste* front &repos queue)

Génère une chaîne de cellules contre imbriquées (une liste pointillée) contenant les arguments. Si la
la liste d'arguments n'a qu'un seul élément, renvoyez-le.

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

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

=> (liste* 1)
1

=> (contre ? (liste* 1 2 3 4))
Vrai

macroexpansion
Nouveau dans la version 0.10.0.

Usage: (macrodévelopper forme)

Renvoie l'expansion macro complète de formulaire.

=> (macrodévelopper '(-> (ab) (xy)))
(u'x' (u'a' u'b') u'y')

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

macroexpand-1
Nouveau dans la version 0.10.0.

Usage: (macroexpansion-1 forme)

Renvoie l'expansion macro en une seule étape de formulaire.

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

fusionner avec
Nouveau dans la version 0.10.1.

Usage: (fusionner avec f &repos Plans)

Renvoie une carte composée du reste des cartes jointes en premier. Si une clé apparaît dans
plus d'une carte, la ou les cartographies de cette dernière (de gauche à droite) seront combinées avec
le mappage dans le résultat en appelant (f val-en-résultat val-en-dernier).

=> (fusion avec (fn [x y] (+ x y)) {"a" 10 "b" 20} {"a" 1 "c" 30})
{u'a' : 11L, u'c' : 30L, u'b' : 20L}

négatif ?
Usage: (négatif ? x)

Retours Vrai if x est inférieur à zéro. Augmente Erreur-type if (Vous n'êtes pas (numérique ? X)).

=> (nég? -2)
Vrai

=> (nég ? 3)
Faux

=> (nég ? 0)
Faux

néant?
Usage: (néant? x)

Retours Vrai if x is nul / Aucun.

=> (nul? néant)
Vrai

=> (nul ? Aucun)
Vrai

=> (néant ? 0)
Faux

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

=> ;; list.append renvoie toujours Aucun
=> (nul ? (.append [1 2 3] 4))
Vrai

rien?
Usage: (aucun? x)

Retours Vrai if x is Aucun.

=> (aucun ? Aucun)
Vrai

=> (aucun ? 0)
Faux

=> (setf x Aucun)
=> (aucun ? x)
Vrai

=> ;; list.append renvoie toujours Aucun
=> (aucun ? (.append [1 2 3] 4))
Vrai

n
Usage: (énième coll n &facultatif [défaut néant])

Renvoie le n-ème élément d'une collection, en comptant à partir de 0. Renvoie la valeur par défaut, nul, Si
hors limites (sauf indication contraire). Augmente Erreur de valeur if n est négatif.

=> (énième [1 2 4 7] 1)
2

=> (énième [1 2 4 7] 3)
7

=> (nul ? (ntième [1 2 4 7] 5))
Vrai

=> (ntième [1 2 4 7] 5 "par défaut")
«Par défaut»

=> (ntième (prendre 3 (drop 2 [1 2 3 4 5 6])) 2))
5

=> (énième [1 2 4 7] -1)
Traceback (appel le plus récent dernier):

ValueError : les indices pour islice() doivent être Aucun ou un entier : 0 <= x <= sys.maxsize.

numérique ?
Usage: (numérique ? x)

Retours Vrai if x est un nombre, tel que défini dans Python nombres.Nombre classe.

=> (numérique ? -2)
Vrai

=> (numérique ? 3.2)
Vrai

=> (numérique ? "foo")
Faux

impair?
Usage: (impair? x)

Retours Vrai if x est impair. Augmente Erreur-type if (Vous n'êtes pas (numérique ? X)).

=> (impair ? 13)
Vrai

=> (impair ? 2)
Faux

=> (impair ? 0)
Faux

pos ?
Usage: (pos. x)

Retours Vrai if x est supérieur à zéro. Augmente Erreur-type if (Vous n'êtes pas (numérique ? X)).

=> (pos? 3)
Vrai

=> (pos?-2)
Faux

=> (pos? 0)
Faux

seconde
Usage: (deuxième coll)

Renvoie le deuxième membre de coll. Équivalent à (obtenir coll 1).

=> (seconde [0 1 2])
1

quelques
Nouveau dans la version 0.10.0.

Usage: (certains pred coll)

Renvoie la première valeur logiquement vraie de (préd x) pour toute x in coll, Autrement nul.
Retour nul if coll est vide.

=> (certains même ? [2 4 6])
Vrai

=> (nul ? (certains même ? [1 3 5]))
Vrai

=> (nul ? (une certaine identité [0 "" []]))
Vrai

=> (une certaine identité [0 "chaîne non vide" []])
'chaîne non vide'

=> (nul ? (certains même ? []))
Vrai

chaîne?
Usage: (chaîne? x)

Retours Vrai if x est une chaîne.

=> (chaîne ? "foo")
Vrai

=> (chaîne ? -2)
Faux

symbole?
Usage: (symbole? x)

Retours Vrai if x est un symbole.

=> (symbole ? 'foo)
Vrai

=> (symbole ? '[a b c])
Faux

zéro?
Usage: (zéro? x)

Retours Vrai if x est zéro.

=> (zéro ? 3)
Faux

=> (zéro ? -2)
Faux

=> (zéro ? 0)
Vrai

Séquence Les fonctions
Les fonctions de séquence peuvent créer ou opérer sur une séquence potentiellement infinie sans
exigeant que la séquence soit entièrement réalisée dans une liste ou un conteneur similaire. Ils font cela en
renvoyant un itérateur Python.

Nous pouvons utiliser le générateur de nombres de Fibonacci infinis canoniques comme exemple d'utilisation
certaines de ces fonctions.

(définition fib []
(setv à 0)
(setv b 1)
(bien que vrai
(rendement a)
(setv (, ab) (, b (+ ab)))))

Noter la (tandis que oui ...) boucle. Si nous exécutons ceci dans le REPL,

=> (mention)


L’appel de la fonction renvoie uniquement un itérateur, mais ne fonctionne pas tant que nous ne le consommons pas.
Essayer quelque chose comme ceci n'est pas recommandé car la boucle infinie s'exécutera jusqu'à ce qu'elle soit terminée.
consomme toute la RAM disponible, ou dans ce cas jusqu'à ce que je la tue.

=> (liste (fib))
[1] 91474 tués hy

Pour obtenir les 10 premiers nombres de Fibonacci, utilisez prendre. Noter que prendre renvoie également un générateur,
donc j'en crée une liste.

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

Pour obtenir le nombre de Fibonacci à l'index 9, (en partant de 0) :

=> (ntième (fib) 9)
34

cycle
Usage: (faire du vélo coll)

Renvoie un itérateur infini des membres de coll.

=> (liste (prise 7 (cycle [1 2 3])))
[1, 2, 3, 1, 2, 3, 1]

=> (liste (prise 2 (cycle [1 2 3])))
[1, 2]

distinct
Usage: (distinct coll)

Renvoie un itérateur contenant uniquement les membres uniques de coll.

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

=> (liste (distinct []))
[]

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

déposer
Usage: (tomber n coll)

Renvoie un itérateur en sautant le premier n les membres de coll. Augmente Erreur de valeur if n is
négatif.

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

=> (liste (drop 4 [1 2 3 4 5]))


=> (liste (drop 0 [1 2 3 4 5]))
[1, 2, 3, 4, 5]

=> (liste (drop 6 [1 2 3 4 5]))
[]

déposer en dernier
Usage: (drop-dernier n coll)

Renvoie un itérateur de tous sauf le dernier n éléments dans coll. Augmente Erreur de valeur if n is
négatif.

=> (liste (drop-last 5 (plage 10 20)))
[10, 11, 12, 13, 14]

=> (liste (drop-last 0 (plage 5)))
[0, 1, 2, 3, 4]

=> (liste (drop-last 100 (plage 100)))
[]

=> (importer itertools)
=> (liste (prendre 5 (drop-last 100 (itertools.count 10))))
[10, 11, 12, 13, 14]

laisser tomber
Usage: (drop-tandis pred coll)

Renvoie un itérateur, en ignorant les membres de coll jusqu'à pred is Faux.

=> (liste (drop-pendant pair ? [2 4 7 8 9]))
[7, 8, 9]

=> (liste (drop-while numérique ? [1 2 3 Aucun "a"])))
[Aucun, tu'a']

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

une fonction filtre
Usage: (filtre pred coll)

Renvoie un itérateur pour tous les éléments de coll qui passe le prédicat pred.

Voir aussi supprimez.

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

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

aplatir
Nouveau dans la version 0.9.12.

Usage: (aplatir coll)

Renvoie une liste unique de tous les éléments de coll, en aplatissant toutes les listes contenues et/ou
tuples.

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

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

répéter
Usage: (répéter fn x)

Renvoie un itérateur de x, fn(x), fn(fn(x)), etc.

=> (liste (prendre 5 (itérer inc 5)))
[5, 6, 7, 8, 9]

=> (liste (prendre 5 (itérer (fn [x] (* x x)) 5)))
[5, 25, 625, 390625, 152587890625]

lire
Usage: (lis &facultatif [à partir du fichier eof])

Lit la prochaine expression Hy de à partir d'un fichier (par défaut sys.stdin), et peut prendre un
un seul octet comme EOF (par défaut une chaîne vide). Augmente EOFErreur if à partir d'un fichier se termine avant
une expression complète peut être analysée.

=> (lire)
(+ 2 2)
('+' 2 2)
=> (évaluer (lire))
(+ 2 2)
4

=> (importer io)
=> (tampon def (io.StringIO "(+ 2 2)\n(- 2 1)"))
=> (eval (apply read [] {tampon "from_file"))
4
=> (eval (apply read [] {tampon "from_file"))
1

=> ; en supposant que « example.hy » contient :
=> ; (imprimer "bonjour")
=> ; (imprimez "hyfriends!")
=> (avec [[f (open "example.hy")]]
... (essayer
... (bien que vrai
... (soit [[exp (lire f)]]
... (faire
... (imprimer "OHY" exp)
... (exp d'évaluation))))
... (attraper [e EOFError]
... (imprimer "EOF!"))))
OHY (« imprimer » « bonjour »)
hello
OHY (« imprimer » « hyfriends ! »)
amis!
EOF!

supprimez
Usage: (supprimer pred coll)

Renvoie un itérateur de coll avec des éléments qui passent le prédicat, pred, supprimé.

Voir aussi une fonction filtre.

=> (liste (supprimer les impairs ? [1 2 3 4 5 6 7]))
[2, 4, 6]

=> (liste (supprimer pos? [1 2 3 4 5 6 7]))
[]

=> (liste (supprimer le négatif ? [1 2 3 4 5 6 7]))
[1, 2, 3, 4, 5, 6, 7]

répéter
Usage: (répéter x)

Renvoie un itérateur (infini) de x.

=> (liste (prendre 6 (répéter "s")))
[vous, vous, vous, vous, vous, vous, vous]

à plusieurs reprises
Usage: (à plusieurs reprises fn)

Renvoie un itérateur en appelant fn à plusieurs reprises.

=> (importer [aléatoire [randint]])

=> (liste (prendre 5 (à plusieurs reprises (fn [] (randint 0 10)))))
[6, 2, 0, 6, 7]

prendre
Usage: (prendre n coll)

Renvoie un itérateur contenant le premier n les membres de coll. Augmente Erreur de valeur if n is
négatif.

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

=> (liste (prendre 4 (répéter "s")))
[vous, vous, vous, vous, vous]

=> (liste (prendre 0 (répéter "s")))
[]

prendre le nième
Usage: (prendre le nième n coll)

Renvoie un itérateur contenant chaque n-ème membre de coll.

=> (liste (prendre le nième 2 [1 2 3 4 5 6 7]))
[1, 3, 5, 7]

=> (liste (prendre le nième 3 [1 2 3 4 5 6 7]))
[1, 4, 7]

=> (liste (prendre le nième 4 [1 2 3 4 5 6 7]))
[1, 5]

=> (liste (prendre le nième 10 [1 2 3 4 5 6 7]))


prendre du temps
Usage: (à prendre pendant pred coll)

Renvoie un itérateur de coll aussi longtemps que pred Retours Vrai.

=> (liste (pos à prendre ? [ 1 2 3 -4 5]))
[1, 2, 3]

=> (liste (prendre pendant neg? [ -4 -3 1 2 5]))
[-4, -3]

=> (liste (prendre en même temps négatif ? [ 1 2 3 -4 5]))
[]

zipavec
Nouveau dans la version 0.9.13.

Usage: (zipavec fn coll ...)

Équivalent à Zip *: français, mais utilise une fonction multi-arguments au lieu de créer un tuple. Si
zipavec est appelé avec N collections, alors fn doit accepter N arguments.

=> (opérateur d'importation)
=> (liste (zipavec opérateur.add [1 2 3] [4 5 6]))
[5, 7, 9]

Reader Macros
Les macros Reader donnent à Lisp le pouvoir de modifier et de modifier la syntaxe à la volée. Tu ne veux pas
Notation polonaise ? Une macro de lecteur peut facilement faire exactement cela. Vous voulez la manière de Clojure d'avoir un
expression régulière ? Les macros de lecture peuvent également le faire facilement.

Syntaxe
=> (defreader ^ [expr] (impression expr))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Bonjour"
"Bonjour"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

Hy n'a pas de littéral pour les tuples. Disons que tu n'aimes pas (, ...) et je veux autre chose. Ce
est un problème que les macros de lecture sont capables de résoudre de manière soignée.

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

Vous pouvez même le faire comme Clojure et avoir un littéral pour les expressions régulières !

=> (importer ré)
=> (defreader r [expr] `(re.compile ~expr))
=> #r".*"


Implémentation
défreader prend un seul caractère comme nom de symbole pour la macro du lecteur ; rien de plus
renverra une erreur. Du point de vue de la mise en œuvre, défreader se développe en un lambda recouvert d'un
décorateur. Ce décorateur enregistre le lambda dans un dictionnaire avec son nom de module et
symbole.

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

# se développe dans (dispatch_reader_macro ...) où le symbole et l'expression sont transmis à
la bonne fonction.

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

AVERTISSEMENT:
En raison d'une limitation du lexer et de l'analyseur de Hy, les macros du lecteur ne peuvent pas redéfinir les valeurs définies.
syntaxe telle que ()[]{}. Ce problème sera très probablement résolu à l’avenir.

Interne Hy Documentation
REMARQUE:
Ces bits sont surtout utiles pour les personnes qui piratent Hy lui-même, mais peuvent également être utilisés pour
ceux qui approfondissent la programmation macro.

Hy Des modèles photo
Introduction à Hy Des modèles photo
Les modèles Hy constituent une très fine couche au-dessus des objets Python classiques, représentant la source Hy
code sous forme de données. Les modèles ajoutent uniquement des informations sur la position de la source et une poignée de méthodes pour
prendre en charge une manipulation propre du code source de Hy, par exemple dans les macros. Pour y parvenir
objectif, les modèles Hy sont des mixins d'une classe Python de base et HyObject.

HyObject
hy.models.HyObject est la classe de base des modèles Hy. Il n'implémente qu'une seule méthode, remplacer,
qui remplace la position source de l'objet actuel par celle passée en argument.
Cela nous permet de garder une trace de la position originale des expressions qui sont modifiées par
macros, que ce soit dans le compilateur ou dans des macros hy pures.

HyObject n'est pas destiné à être utilisé directement pour instancier des modèles Hy, mais uniquement en tant que mixin
pour les autres cours.

Composé Des modèles photo
Les listes entre parenthèses et entre crochets sont analysées comme des modèles composés par l'analyseur Hy.

HyListe
hy.models.list.HyList est la classe de base des modèles Hy « itérables ». Son utilisation fondamentale est de
représente entre parenthèses [] listes, qui, lorsqu'elles sont utilisées comme expression de niveau supérieur, se traduisent par
Littéraux de liste Python en phase de compilation.

L'ajout d'une HyList à un autre objet itérable réutilise la classe de l'objet de gauche,
un comportement utile lorsque vous souhaitez concaténer des objets Hy dans une macro, par exemple.

HyExpression
hy.models.expression.HyExpression hérite HyListe pour les parenthèses () expressions. Le
Le résultat de la compilation de ces expressions dépend du premier élément de la liste : le
le compilateur distribue les expressions entre les formulaires spéciaux du compilateur, les macros définies par l'utilisateur et
appels de fonctions Python réguliers.

HyDict
hy.models.dict.HyDict hérite HyListe pour les crochets bouclés {} expressions, qui compilent
jusqu'à un littéral de dictionnaire Python.

La décision d'utiliser une liste au lieu d'un dict comme classe de base pour HyDict permet plus facilement
manipulation des dicts dans les macros, avec l'avantage supplémentaire de permettre des expressions composées
comme touches de dictée (comme, par exemple, le HyExpression La classe Python n'est pas hachable).

Atomique Des modèles photo
Dans le flux d'entrée, des chaînes entre guillemets, respectant la notation Python pour les chaînes,
sont analysés comme un seul jeton, qui est directement analysé comme un HyString.

Une chaîne ininterrompue de caractères, à l'exclusion des espaces, des crochets, des guillemets et des guillemets doubles.
et commentaires, est analysé comme un identifiant.

Les identifiants sont résolus en modèles atomiques pendant la phase d'analyse dans l'ordre suivant :

· HyEntier

· HyFloat

· HyComplexe (si l'atome n'est pas nu j)

· Mot-clé Hy (si l'atome commence par :)

· HySymbole

HyString
hy.models.string.HyString est la classe de base des modèles Hy équivalents aux chaînes. Ça aussi
représente des littéraux de chaîne entre guillemets doubles, "", qui se compile en chaîne Unicode
littéraux en Python. HyStrings hérite des objets Unicode dans Python 2 et des objets chaîne dans
Python 3 (et ne dépendent donc pas de l'encodage).

HyString les modèles basés sur sont immuables.

Les chaînes littérales Hy peuvent s'étendre sur plusieurs lignes et sont considérées par l'analyseur comme une seule.
unité, en respectant les échappements Python pour les chaînes Unicode.

Numérique Des modèles photo
hy.models.integer.HyInteger représente des littéraux entiers (en utilisant le Long tapez sur Python 2,
ainsi que int sur Python 3).

hy.models.float.HyFloat représente des littéraux à virgule flottante.

hy.models.complex.HyComplex représente des littéraux complexes.

Les modèles numériques sont analysés à l'aide de la routine Python correspondante et d'un python numérique valide
les littéraux seront transformés en leur homologue Hy.

HySymbole
hy.models.symbol.HySymbol est le modèle utilisé pour représenter les symboles dans le langage Hy. Il
hérite HyString.

HySymbole les objets sont mutilés lors de la phase d'analyse, pour faciliter l'interopérabilité de Python :

· Symboles entourés d'astérisques (*) sont mis en majuscules ;

· Tirets (-) sont transformés en traits de soulignement (_);

· Un point d'interrogation final (?) est transformé en leader est_.

Attention : comme la modification est effectuée pendant la phase d'analyse, il est possible de
générer par programme des HySymbols qui ne peuvent pas être générés avec le code source Hy. Tel que
Le mécanisme est utilisé par gensym pour générer des symboles « non internes ».

Mot-clé Hy
hy.models.keyword.HyKeyword représente des mots-clés dans Hy. Les mots-clés sont des symboles commençant par
a :. La classe hérite HyString.

Distinguer Mots-clés Hy de HySymboles, sans possibilité (involontaire)
conflits, le caractère Unicode à usage privé "\uFDD0" est ajouté au début du mot-clé littéral
avant stockage.

Inconvénients Cellules
hy.models.cons.HyCons est une représentation de Python-friendly contre cellules. Les inconvénients des cellules sont
particulièrement utile pour imiter les fonctionnalités des variantes LISP "habituelles" telles que Scheme ou Common
Zézayer.

Une cellule contre est un objet à 2 éléments, contenant un fournisseur (tête) et un cdr (queue). Dans certains Lisp
variantes, la cellule contre est l'élément de base fondamental, et les expressions S sont en fait
représentés sous forme de listes chaînées de cellules contre. Ce n'est pas le cas à Hy, comme d'habitude
les expressions sont constituées de listes Python enveloppées dans un HyExpression. Cependant, l' HyCons
imite ainsi le comportement des variantes Lisp "habituelles":

· (les inconvénients quelque chose néant) is (HyExpression [quelque chose])

· (les inconvénients quelque chose une liste) is ((taper une liste) (+ [quelque chose] une liste)) (si
une liste hérite de liste).

· (obtenir (les inconvénients a b) 0) is a

· (tranche (les inconvénients a b) 1) is b

Hy prend en charge une syntaxe de liste pointée, où '(un . b) veux dire (les inconvénients 'a 'b) ainsi que '(un b . c) veux dire
(les inconvénients 'a (les inconvénients 'b 'c)). Si le compilateur rencontre une cellule contre au niveau supérieur, il génère
une erreur de compilation.

HyCons encapsule les arguments passés (car et cdr) dans des types Hy, pour faciliter la manipulation de
contre les cellules dans un contexte macro.

Hy Interne THÉORIE
Vue d’ensemble
Les composants internes de Hy fonctionnent en agissant comme une interface pour le bytecode Python, de sorte que Hy lui-même
se compile en Python Bytecode, permettant à un runtime Python non modifié d'exécuter du code Hy,
sans même s'en apercevoir.

Pour ce faire, nous traduisons Hy en une structure de données Python AST interne, et
construire cet AST dans le bytecode Python à l'aide de modules du standard Python
bibliothèque, afin que nous n'ayons pas à dupliquer tout le travail des composants internes de Python pour chaque
version unique de Python.

Hy fonctionne en quatre étapes. Les sections suivantes couvriront chaque étape de Hy, de la source à
Durée.

Étapes 1 ainsi que 2: Tokeniser ainsi que Analyse
La première étape de la compilation de Hy consiste à transformer la source en jetons que nous pouvons gérer. Nous
utilisez un projet appelé rply, qui est un analyseur vraiment sympa (et rapide), écrit dans un sous-ensemble
de Python appelé rpython.

Le code lexing est entièrement défini dans hy.lex.lexer. Ce code définit principalement le Hy
grammaire, et toutes les parties les plus difficiles sont prises en charge par réponse - nous définissons simplement
"rappels" pour répondre hy.lex.parser, qui prend les jetons générés et renvoie le
Modèles Hy.

Vous pouvez considérer les modèles Hy comme "AST" pour Hy, c'est sur quoi les macros opèrent.
(directement), et c'est ce que le compilateur utilise lorsqu'il compile Hy.

VOIR AUSSI:
Section Hy Des modèles photo pour plus d'informations sur les modèles Hy et leur signification.

étapes 3: Hy Compilation à Python AST
C’est là que se produit l’essentiel de la magie de Hy. C'est ici que nous prenons Hy AST (les modèles),
et compilez-les dans Python AST. Quelques choses géniales se produisent ici pour dépasser quelques-unes
problèmes dans AST, et travailler dans le compilateur est l'un des travaux les plus importants que nous effectuons
avoir.

Le compilateur est un peu complexe, alors ne vous sentez pas mal si vous ne le comprenez pas du premier coup,
cela peut prendre un peu de temps pour y parvenir.

Le principal point d'entrée du compilateur est HyASTCompiler.compile. Cette méthode est invoquée, et
la seule véritable méthode "publique" sur la classe (c'est-à-dire que nous ne promettons pas vraiment le
API au-delà de cette méthode).

En fait, même en interne, on ne récure presque jamais directement, on force presque toujours
l'arbre Hy à travers compiler, et le fera souvent avec des sous-éléments d'une expression
que nous avons. C'est au répartiteur basé sur le type de répartir correctement les sous-éléments.

Toutes les méthodes qui effectuent une compilation sont marquées du @builds() décorateur. Tu peux
soit vous transmettez la classe du modèle Hy qu'il compile, soit vous pouvez utiliser une chaîne pour
expressions. Je vais clarifier ça dans une seconde.

Prénom Étape Type-Expédition
Commençons par le compiler méthode. La première chose que nous faisons est de vérifier le type de chose
nous construisons. Nous cherchons à voir si nous avons une méthode qui peut construire le taper() que nous
avez et envoyez-le à la méthode qui peut le gérer. Si nous n'avons aucune méthode qui puisse
construisons ce type, nous élevons un Exception.

Par exemple, si nous avons un HyString, nous avons un mappage presque 1 pour 1 de Hy AST vers Python
AST. Le chaîne_compilée méthode prend le HyString, et renvoie un ast.Str()
rempli avec les numéros de ligne et le contenu corrects.

Macro-Développer
Si nous obtenons un HyExpression, nous allons essayer de voir s'il s'agit d'une macro connue, et pousser pour avoir
il s'est élargi en invoquant hy.macros.macroexpand, puis repoussez le résultat dans
HyASTCompiler.compile.

Deuxièmement Étape Expression-Dispatch
Le seul cas particulier est celui HyExpression, puisque nous devons créer différents AST en fonction
sur le formulaire spécial en question. Par exemple, lorsque nous heurtons un (si oui oui faux), Nous
besoin de générer un ast.Si, et compilez correctement les sous-nœuds. C'est là que le @builds()
avec une chaîne comme argument entre.

Pour le expression_compilation (qui est défini par un @builds(HyExpression)) expédiera
basé sur la chaîne du premier argument. Si, pour une raison quelconque, le premier argument n'est pas
une chaîne, il gérera également correctement ce cas (très probablement en levant un Exception).

Si la chaîne n'est pas connue de Hy, il créera par défaut un ast.Appel, qui tentera de
faire un appel d'exécution (en Python, quelque chose comme truc()).

Questions Frappé avec Python AST
Python AST est génial ; c'est ce qui nous a permis d'écrire un projet aussi puissant en plus de
Python sans avoir à combattre Python trop durement. Comme toute chose, nous avons eu notre juste part de
problèmes, et voici une courte liste des problèmes courants que vous pourriez rencontrer.

Python différencie jusqu'à XNUMX fois Déclarations ainsi que Expressions.

Cela peut ne pas sembler très grave -- en fait, pour la plupart des programmeurs Python, cela
deviendra bientôt un moment « Eh bien, ouais ».

En Python, faire quelque chose comme :

impression en x in gamme(10): pass, Parce impression imprime les expressions, et en n'est pas un
expression, c'est une instruction de flux de contrôle. Des choses comme 1 + 1 sont des expressions, tout comme lambda
x: 1 + x, mais d'autres fonctionnalités linguistiques, telles que if, enou tout en sont des déclarations.

Puisqu'ils n'ont aucune "valeur" pour Python, cela rend le travail dans Hy difficile, car faire quelque chose
comme (imprimer (si oui oui FAUX)) ce n’est pas seulement courant, c’est attendu.

En conséquence, nous modifions automatiquement les choses à l'aide d'un Résultat objet, où nous proposons n'importe quel ast.stmt
qui doit être exécuté, et un seul ast.expr qui peut être utilisé pour obtenir la valeur de n'importe quoi
venait juste d'être exécuté. Hy fait cela en forçant l'affectation aux choses pendant l'exécution.

A titre d'exemple, le Hy :

(imprimer (si vrai vrai faux))

Se transformera en :

si vrai:
_mangled_name_here = Vrai
autre:
_mangled_name_here = Faux

imprimer _mangled_name_here

OK, c'était un peu un mensonge, puisque nous transformons cette déclaration en :

imprimer Vrai si Vrai sinon Faux

En forçant les choses à ast.expr si nous le pouvons, mais l'idée générale tient.

étapes 4: Python bytecode Sortie ainsi que Runtime
Une fois que nous avons un arbre Python AST terminé, nous pouvons essayer de le compiler en Python.
bytecode en le poussant eval. À partir de maintenant, nous n'avons plus le contrôle, et
Python s'occupe de tout. C'est pourquoi des éléments comme les traces Python, pdb et
Les applications Django fonctionnent.

Hy Macros
En utilisant gensyme en Plus sûr Macros
Lors de l'écriture de macros, il faut faire attention à éviter de capturer des variables externes ou d'utiliser
noms de variables susceptibles d'entrer en conflit avec le code utilisateur.

Nous utiliserons un exemple de macro nif (voir
http://letoverlambda.com/index.cl/guest/chap3.html#sec_5 pour une description plus complète.)
nif est un exemple, quelque chose comme un chiffre if, où, d'après l'expression, l'un des
3 formes sont appelées selon que l'expression est positive, nulle ou négative.

Un premier passage pourrait ressembler à ceci :

(defmacro nif [expr forme pos forme zéro forme négative]
`(laissez [[nom-obscur ~expr]]
(cond [(pos? obscur-name) ~pos-form]
[(zéro ? nom-obscur) ~ forme zéro]
[(nég? nom-obscur) ~ forme-nég])))

De nom-obscur est une tentative de choisir un nom de variable pour ne pas entrer en conflit avec d'autres
code. Mais bien sûr, même si cela est bien intentionné, cela ne constitue pas une garantie.

La méthode gensym est conçue pour générer un nouveau symbole unique pour une telle occasion.
Une bien meilleure version de nif serait:

(defmacro nif [expr forme pos forme zéro forme négative]
(soit [[g (gensym)]]
`(laissez [[~g ~expr]]
(cond [(pos? ~g) ~pos-form]
[(zéro? ~g) ~forme zéro]
[(nég? ~g) ~forme négative]))))

C’est un cas facile puisqu’il n’y a qu’un seul symbole. Mais s'il en faut plusieurs
gensym, il existe une deuxième macro avec-gensyms qui s'étend essentiellement à une série de laisser
déclarations:

(avec-gensyms [a b c]
...)

s'étend à :

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

donc notre réécrit nif ressemblerait à:

(defmacro nif [expr forme pos forme zéro forme négative]
(avec-gensyms [g]
`(laissez [[~g ~expr]]
(cond [(pos? ~g) ~pos-form]
[(zéro? ~g) ~forme zéro]
[(nég? ~g) ~forme négative]))))

Enfin, nous pouvons créer une nouvelle macro qui fait tout cela pour nous. defmacro/g! prendra
tous les symboles commençant par g! et appelle automatiquement gensyme avec le reste du
symbole. Donc Géorgie deviendrait (gensym "un").

Notre version finale de nif, construit avec defmacro/g! devient:

(defmacro/g! nif [expr forme pos forme zéro forme négative]
`(laissez [[~g!res ~expr]]
(cond [(pos? ~g!res) ~pos-form]
[(zéro ? ~g!res) ~forme zéro]
[(nég? ~g!res) ~forme négative]))))

Vérification Macro Arguments ainsi que Élevage Exceptions
Hy Compilateur Built-Ins

DONATEUR MODULES INDEX

Contenu:

Anaphorique Macros
Nouveau dans la version 0.9.12.

Le module de macros anaphoriques rend la programmation fonctionnelle dans Hy très concise et facile à
lire.
Une macro anaphorique est un type de macro de programmation qui capture délibérément une forme
fourni à la macro qui peut être désigné par une anaphore (une expression faisant référence
à un autre). - Wikipédia (http://en.wikipedia.org/wiki/Anaphoric_macro)

Macros
ap-si
Usage: (ap-si (toto) (imprimer il))

Évalue la première forme pour la véracité et la lie à it dans le vrai et le faux
branches.

une pêche
Usage: (une pêche [1 2 3 4 5] (imprimer il))

Évaluez le formulaire pour chaque élément de la liste pour les effets secondaires.

ap-de temps en temps
Usage: (ap-de temps en temps liste pred corps)

Évaluez le formulaire pour chaque élément où le formulaire de prédicat renvoie Vrai.

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

ap-carte
Usage: (ap-carte formulaire liste)

La forme anaphorique de map fonctionne comme une map classique sauf qu'au lieu d'une fonction
objet, il prend une forme Hy. Le nom spécial it est lié à l'objet actuel à partir du
liste dans l’itération.

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

ap-map-quand
Usage: (ap-map-quand predfn rep liste)

Évaluez un mappage sur la liste à l'aide d'une fonction de prédicat pour déterminer quand appliquer le
formulaire.

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

=> (liste (ap-map-quand même ? (* it 2) [1 2 3 4]))
[1, 4, 3, 8]

filtre ap
Usage: (ap-filtre formulaire liste)

Comme avec ap-carte nous prenons une forme spéciale au lieu d'une fonction pour filtrer les éléments du
liste. Le nom spécial it est lié à l'élément actuel dans l'itération.

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

ap-rejeter
Usage: (ap-rejeter formulaire liste)

Cette fonction fait le contraire de filtre ap, il rejette les éléments passant le
prédicat. Le nom spécial it est lié à l'élément actuel dans l'itération.

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

ap-dotimes
Utilisation (ap-dotimes n corps)

Cette fonction évalue le corps n fois, avec la variable spéciale it lié de 0 à
1-n. C’est utile pour les effets secondaires.

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

ap-premier
Utilisation (ap-premier predfn liste)

Cette fonction renvoie le premier élément qui passe le prédicat ou Aucun, Avec le
variable spéciale it lié à l’élément actuel dans l’itération.

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

ap-dernier
Utilisation (ap-dernier predfn liste)

Cette fonction renvoie le dernier élément qui passe le prédicat ou Aucun, avec le spécial
variable it lié à l’élément actuel dans l’itération.

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

ap-réduire
Utilisation (ap-réduire formulaire liste &facultatif valeur initiale)

Cette fonction renvoie le résultat de l'application du formulaire aux 2 premiers éléments du corps et
appliquer le résultat et le 3ème élément etc. jusqu'à ce que la liste soit épuisée. En option un
la valeur initiale peut être fournie afin que la fonction soit appliquée à la valeur initiale et le
premier élément à la place. Cela expose l'élément itéré comme it et le courant
valeur accumulée comme selon.

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

boucle/récurrence
Nouveau dans la version 0.10.0.

La boucle / se reproduire la macro donne aux programmeurs un moyen simple d'utiliser l'optimisation des appels finals (TCO)
dans leur code Hy.
Un appel de fin est un appel de sous-programme qui se produit dans une autre procédure en tant que dernier appel.
action; il peut produire une valeur de retour qui est ensuite immédiatement renvoyée par l'appelant
procédure. Si un appel effectué par un sous-programme, de telle sorte qu'il puisse éventuellement conduire
à ce même sous-programme étant à nouveau appelé dans la chaîne d'appel, est en position de queue,
un tel sous-programme est dit récursif en queue, ce qui est un cas particulier de récursion.
Les appels de queue sont importants car ils peuvent être implémentés sans ajouter de nouvelle pile
trame à la pile d’appels. La majeure partie du cadre de la procédure actuelle n'est pas nécessaire
plus, et il peut être remplacé par le cadre de l'appel de queue. Le programme peut alors sauter
au sous-programme appelé. Produire un tel code au lieu d'une séquence d'appel standard est
appelé élimination des appels de queue, ou optimisation des appels de queue. L'élimination des appels de queue permet
les appels de procédure en position de queue pour être implémentés aussi efficacement que les instructions goto,
permettant ainsi une programmation structurée efficace. - Wikipédia (-
http://en.wikipedia.org/wiki/Tail_call)

Macros
boucle
boucle établit un point de récursion. Avec boucle, se reproduire relie à nouveau les variables définies dans le
point de récursion et renvoie l’exécution du code à ce point de récursion. Si se reproduire est utilisé dans
une position sans queue, une exception est levée.

Usage: (boucle fixations &repos corps)

Mise en situation :

(nécessite hy.contrib.loop)

(définition factorielle [n]
(boucle [[i n] [acc 1]]
(si (zéro ? je)
selon
(récurrent (déc i) (* acc i)))))

(factoriel 1000)

défmulti
Nouveau dans la version 0.10.0.

défmulti vous permet de surcharger une fonction par arité avec le nombre donné d'arguments et/ou de kwargs.
Inspiré par le point de vue de Clojure défn.

=> (nécessite hy.contrib.multi)
=> (défmulti amusant
... ([un] "un")
... ([ab] "ab")
... ([abc] "abc"))
=> (amusant 1)
"une"
=> (amusant 1 2)
"un B"
=> (amusant 1 2 3)
"abc"

Piratage ON HY

S'inscrire nos Hyve!
S'il vous plaît, venez pirater Hy !

S'il vous plaît, venez passer du temps avec nous #hy on irc.freenode.net!

S'il vous plaît, parlez-en sur Twitter avec le #hy hashtag!

S'il vous plaît, bloguez à ce sujet !

S'il vous plaît, ne le vaporisez pas sur la clôture de votre voisin (sans le demander gentiment) !

Hack!
Faire cela:

1. Créer un virtuel sûr, heureux et sain:

$ virtualenv venv

et activez-le :

$ . venv/bin/activer

ou de l'utilisation enveloppe virtuelle pour créer et gérer votre environnement virtuel :

$ mkvirtualenv hy
$ travail sur hy

2. Obtenez le code source :

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

ou utilisez votre fourchette :

$ clone de git [email protected]:/hy.git

3. Installer pour le piratage :

$ cd hy/
$ pip install -e .

4. Installez les autres exigences de développement :

$ pip install -r exigences-dev.txt

5. Faites des choses géniales ; faites hurler quelqu'un de plaisir ou de dégoût face à ce que vous avez fait.

Les tests!
Les tests sont situés dans tests /. Nous utilisons nez.

Pour exécuter les tests:

$ tests de nez

Écrivez des tests --- les tests sont bons !

De plus, il est bon d'exécuter les tests pour toutes les plateformes prises en charge et pour celles conformes à PEP 8.
code. Vous pouvez le faire en exécutant tox :

$ tox

Document!
La documentation se trouve dans docs /. Nous utilisons Sphinx.

Pour créer les documents en HTML :

$ cd docs
$ faire du HTML

Écrivez des documents --- les documents sont bons ! Même ce doc !

Contribuer
Les contributions sont les bienvenues et grandement appréciées, chaque petit geste contribue à rendre Hy plus
impressionnant.

Les demandes de tirage sont géniales ! Nous les aimons; voici un guide rapide :

· Forkez le dépôt et créez une branche thématique pour une fonctionnalité/un correctif. Évitez d’apporter des modifications directement
sur la branche principale.

· Toutes les fonctionnalités entrantes doivent être accompagnées de tests.

· Avant de soumettre un PR, veuillez exécuter les tests et vérifier votre code par rapport au style
guide. Vous pouvez faire ces deux choses à la fois :

$ faire d

· Transformez les commits en unités logiques, afin qu'il soit plus facile de suivre et de naviguer plus tard. Avant
en soumettant un PR, essayez de regrouper les commits dans des ensembles de modifications faciles à revenir
plus tard. Assurez-vous également de ne pas laisser d'espaces parasites dans les ensembles de modifications ; ce
évite la création de commits de correctifs d'espaces plus tard.

· En ce qui concerne les messages de validation, essayez de respecter ce qui suit :

· Essayez de respecter la limite de 50 caractères pour la première ligne des messages de validation Git.

· Pour plus de détails/explications, suivez ceci avec une ligne vide et continuez
décrivant le commit en détail.

· Enfin, ajoutez-vous au fichier AUTHORS (en tant que commit séparé) : vous le méritez :)

· Tous les changements entrants doivent être acceptés par 2 membres différents de l'équipe principale d'Hylang.
Un examen supplémentaire est clairement le bienvenu, mais nous avons besoin d'un minimum de 2 approbations pour tout
changer.

· Si un membre principal envoie un PR, veuillez trouver 2 membres principaux qui n'incluent pas le
Soumissionnaire de relations publiques. L'idée ici est que l'on peut travailler avec l'auteur des relations publiques, et un deuxième répond
l'ensemble des modifications.

· Pour la documentation et autres modifications triviales, nous sommes prêts à fusionner après un ACK. Nous avons
faible couverture, ce serait donc formidable de maintenir cette barrière basse.

Core ÉQUIPE
L'équipe de développement principale de Hy est composée des développeurs suivants :

· Julien Danjou

· Morten Linderud

· J Kenneth King

· Gergely Nagy

· Tuukka Tortue

· Karen Rustad

· Abhishek L

· Christopher Allan Webber

· Konrad Hinsen

· Volonté Kahn-Greene

· paul Tagliamonte

· Nicolas Dandrimont

· Bob Tolbert

· Berker Pékin

· Clinton N. Dreibach

· il semaj

Utilisez hy en ligne en utilisant les services onworks.net