hy - Online nel cloud

PROGRAMMA:

NOME

hy - hy Documentazione [immagine: Hy] [immagine]

STIMA SMART DI Hy https://try-hy.appspot.com

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

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

Lista hylang-discutere

IRC #ciao su Freenode

Costruire status
Travis CI.INDENTATO

Hy è un meraviglioso dialetto di Lisp incorporato in Python.

Poiché Hy trasforma il suo codice Lisp in Python Abstract Syntax Tree, hai
tutto il bellissimo mondo di Python a portata di mano, in forma Lisp!

Contenuto:

AVVIO RAPIDO

[immagine: Le coccole di Karen Rustard] [immagine]

(Grazie a Karen Rustad per Coccole!)

COME A GET HY VERO FAST:

1. Creare un virtuale Python Ambiente.

2. Attiva il tuo ambiente virtuale Python.

3. Installa hy da PyPI con seme install hy.

4. Inizia un REPL con hy.

5. Digita cose nel REPL:

=> (stampa "Ciao!")
Hy!
=> (defn salutinm [nome] (stampa (+ "Hy " nome "!")))
=> (salutinm "TuoNome")
Ciao TuoNome!

eccetera

6. Premi CTRL-D quando hai finito.

OH MIO DIO! Quello è Stupefacente! I volere a scrivere a Hy .

7. Apri un editor di programmazione d'élite e digita:

(stampa "Stavo per codificare nella sintassi Python, ma poi ho ottenuto Hy.")

8. Salva con nome fantastico.hy.

9. Ed esegui il tuo primo programma Hy:

hy fantastico.hy

10
Fai un respiro profondo per non iperventilare.

11
Sorridi in modo malvagio e sgattaiola nel tuo nascondiglio e fai cose indicibili.

TUTORIAL

Benvenuto nel tutorial di Hy!

In poche parole, Hy è un dialetto Lisp, ma che converte la sua struttura in Python...
letteralmente una conversione nell'albero della sintassi astratta di Python! (O per dirla in modo più grezzo
termini, Hy è lisp-stick su un Python!)

Questo è piuttosto interessante perché significa che Hy è diverse cose:

· Un Lisp che sembra molto pitone

· Per Lispers, un ottimo modo per usare i folli poteri di Lisp ma nel vasto mondo di Python
librerie (perché sì, ora puoi scrivere un'applicazione Django in Lisp!)

· Per i Pythonisti, un ottimo modo per iniziare ad esplorare Lisp, comodamente da Python!

· Per tutti: una lingua piacevole che ha molte idee chiare!

Standard intro a Lisp per pythonisti
Ok, forse non hai mai usato Lisp prima, ma hai usato Python!

Un programma "ciao mondo" in Hy è in realtà semplicissimo. Proviamolo:

(stampa "ciao mondo")

Vedere? Facile! Come avrai intuito, questa è la stessa della versione Python di:

stampa "ciao mondo"

Per sommare un po' di matematica semplicissima, potremmo fare:

(+1)

Che restituirebbe 4 e sarebbe l'equivalente di:

1 + 3

Quello che noterai è che il primo elemento nell'elenco è la funzione che viene chiamata e il
il resto degli argomenti sono gli argomenti passati. Infatti, in Hy (come con la maggior parte
Lisp) possiamo passare più argomenti all'operatore più:

(+ 1 3 55)

Che ritornerebbe 59.

Forse hai già sentito parlare di Lisp ma non ne sai molto. Lisp non è difficile come te
potrebbe pensare, e Hy eredita da Python, quindi Hy è un ottimo modo per iniziare a imparare il Lisp.
La cosa principale che è ovvia del Lisp è che ci sono molte parentesi. Questo potrebbe
all'inizio sembra confuso, ma non è così difficile. Diamo un'occhiata a qualche semplice matematica che è
racchiuso in un mucchio di parentesi che potremmo inserire nell'interprete Hy:

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

Questo restituirebbe 38. Ma perché? Bene, potremmo guardare l'espressione equivalente in
pitone:

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

Se dovessi provare a capire come funziona quanto sopra in Python, lo faresti ovviamente
calcolare i risultati risolvendo ogni parentesi interna. È la stessa idea di base in
Hy. Proviamo prima questo esercizio in Python:

risultato = ((1 + 3 + 88) / 2) - 8
# semplificato per...
risultato = (92 / 2) - 8
# semplificato per...
risultato = 46 - 8
# semplificato per...
risultato = 38

Ora proviamo la stessa cosa in Hy:

(setv risultato (- (/ (+ 1 3 88) 2) 8))
; semplificato in...
(risultato setv (- (/ 92 2) 8))
; semplificato in...
(risultato setv (- 46 8))
; semplificato in...
(risultato setv 38)

Come probabilmente avrai intuito, quest'ultima espressione con setv significa assegnare la variabile
"risultato" a 38.

Vedere? Non troppo difficile!

Questa è la premessa di base di Lisp. Lisp sta per "elaborazione lista"; questo significa che il
la struttura del programma è in realtà elenchi di elenchi. (Se hai familiarità con Python
liste, immagina l'intera stessa struttura come sopra ma con parentesi quadre, qualsiasi
sarai in grado di vedere la struttura sopra sia come programma che come struttura dati.) Questo è
più facile da capire con più esempi, quindi scriviamo un semplice programma Python, testiamolo,
e quindi mostra il programma Hy equivalente:

def semplice_conversazione():
print "Ciao! Vorrei conoscerti. Parlami di te!"
name = raw_input("Come ti chiami?")
age = raw_input("Qual è la tua età?")
stampa "Ciao " + nome + "! Vedo che hai " + età + " anni."

conversazione_semplice()

Se eseguissimo questo programma, potrebbe andare così:

Ciao! vorrei conoscerti. Parlami di te!
Come ti chiami? Gary
Quanti anni hai? 38
Ciao Gary! Vedo che hai 38 anni.

Ora diamo un'occhiata al programma Hy equivalente:

(def. conversazione semplice []
(stampa "Ciao! Vorrei conoscerti. Parlami di te!")
(setv name (raw-input "Come ti chiami?"))
(setv age (raw-input "Qual è la tua età?"))
(stampa (+ "Ciao " nome "! Vedo che sei "
età " anni.")))

(semplice conversazione)

Se guardi il programma sopra, purché ricordi che il primo elemento in ciascuno
lista del programma è la funzione (o macro... ci arriveremo più avanti) che viene chiamata
e che il resto sono gli argomenti, è abbastanza facile capire cosa significhi tutto questo.
(Come probabilmente hai anche intuito, def è il metodo Hy per definire i metodi.)

Tuttavia, molte persone all'inizio trovano questo confuso perché ci sono così tante parentesi,
ma ci sono molte cose che possono aiutare a rendere tutto più semplice: mantenere il rientro piacevole e
usa un editor con corrispondenza tra parentesi (questo ti aiuterà a capire cosa ciascuno
parentesi si accoppia con) e le cose inizieranno a sentirsi a proprio agio.

Ci sono alcuni vantaggi nell'avere una struttura del codice che in realtà è un dato molto semplice
struttura su cui si basa il nucleo di Lisp. Per prima cosa, significa che i tuoi programmi sono
facile da analizzare e che l'intera struttura effettiva del programma sia esposta molto chiaramente
a te. (C'è un passaggio in più nel modo in cui la struttura che vedi viene convertita in quella di Python
proprie rappresentazioni ... in Lisp "più puri" come Common Lisp o Emacs Lisp, i dati
struttura che vedi nel codice e la struttura dati che viene eseguita è molto di più
letteralmente vicino.)

Un'altra implicazione di ciò sono le macro: se la struttura di un programma è un semplice dato
struttura, ciò significa che puoi scrivere codice in grado di scrivere codice molto facilmente, il che significa che
l'implementazione di funzionalità linguistiche completamente nuove può essere molto veloce. Prima di Hy, questo non lo era
molto possibile per i programmatori Python... ora anche tu puoi fare uso delle incredibili macro
potenza (fai attenzione a non puntarli verso i piedi)!

Hy is a Al gusto di Lisp Python
Hy si converte nell'albero di sintassi astratto di Python, quindi presto inizierai a scoprire tutto
il familiare potere di Python è a portata di mano.

Hai pieno accesso ai tipi di dati di Python e alla libreria standard in Hy. sperimentiamo
con questo nell'interprete hy:

=> [1 2 3]
[1, 2, 3]
=> {"cane" "abbaiare"
... "gatto" "miao"}
...
{'cane': 'abbaia', 'gatto': 'miao'}
=> (, 1 2 3)
(1, 2, 3)

Se hai familiarità con altri Lisps, potresti essere interessato al fatto che Hy supporti il ​​Common
Metodo di citazione Lisp:

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

Hai anche accesso a tutti i metodi carini dei tipi incorporati:

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

Che cos'è questo? Sì, in effetti, questo è esattamente lo stesso di:

" fooooo ".strip()

Esatto --- Lisp con notazione a punti! Se abbiamo questa stringa assegnata come variabile,
può anche fare quanto segue:

(setv questa stringa " fooooo ")
(questo-stringa.striscia)

E i condizionali?:

(se (provare qualcosa)
(stampa "questo è se vero")
(stampa "questo è se falso"))

Come puoi dire sopra, il primo argomento per if è un test di verità, il secondo argomento è
il corpo se vero, e il terzo argomento (opzionale!) è se falso (es. altro).

Se hai bisogno di fare condizionali più complessi, scoprirai che non hai Elif
disponibile in Hy. Invece, dovresti usare qualcosa chiamato cond. In Python, potresti farlo
qualcosa di simile a:

qualche var = 33
se somevar > 50:
print "Quella variabile è troppo grande!"
elif somevar < 10:
print "Quella variabile è troppo piccola!"
altro:
print "Quella variabile è giustissima!"

In Hy, faresti:

(cond
[(> qualcosa come 50)
(stampa "Quella variabile è troppo grande!")]
[(< variabile 10)
(stampa "Quella variabile è troppo piccola!")]
[vero
(stampa "Quella variabile è giustissima!")])

Quello che noterai è che cond si spegne tra un'istruzione che viene eseguita e
controllato in modo condizionale per vero o falso, e poi un po' di codice da eseguire se gira
fuori per essere vero. Noterai anche che il altro è implementato alla fine semplicemente da
controllando vero -- è perché vero sarà sempre vero, quindi se arriviamo così lontano, lo faremo
esegui sempre quello!

Potresti notare sopra che se hai un codice come:

(se qualche condizione
(corpo-se-vero)
(corpo-se-falso))

Ma aspetta! Cosa succede se si desidera eseguire più di un'istruzione nel corpo di una delle
questi?

Puoi fare quanto segue:

(se (provare qualcosa)
(di
(stampa "questo è se vero")
(stampa "e perché no, continuiamo a parlare di quanto sia vero!))
(stampa "questo è ancora semplicemente falso"))

Puoi vedere che abbiamo usato do per avvolgere più dichiarazioni. Se conosci altri
Lips, questo è l'equivalente di programma altrove.

I commenti iniziano con il punto e virgola:

(stampa "questo verrà eseguito")
; (stampa "ma questo non lo farà")
(+ 1 2 3) ; eseguiremo l'aggiunta, ma non questo commento!

Il loop non è difficile, ma ha una struttura speciale. In Python, potremmo fare:

per io in gamma(10)
print "'i' è ora a " + str(i)

L'equivalente in Hy sarebbe:

(per [i (intervallo 10)]
(print (+ "'i' è ora a " (str i))))

Puoi anche importare e utilizzare varie librerie Python. Per esempio:

(sistema operativo di importazione)

(if (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/anotherdir")
(stampa "Ehi, quel percorso non c'è!"))

Gestori di contesto di Python (con dichiarazioni) sono usati in questo modo:

(con [[f (apri "/tmp/data.in")]]
(stampa (.leggi f)))

che equivale a:

con open("/tmp/data.in") come f:
stampa f.leggi()

E sì, abbiamo la comprensione delle liste! In Python potresti fare:

quote_quadrate = [
pot(num, 2)
per numero in gamma(100)
se num % 2 == 1]

In Hy, potresti fare queste cose come:

(setv odds al quadrato
(lista-comp
(pow numero 2)
(numero (intervallo 100))
(= (% numero 2) 1)))

; E, un esempio rubato spudoratamente da una pagina di Clojure:
; Elenchiamo tutti i blocchi di una Scacchiera:

(lista-comp
(, xy)
(x (intervallo 8)
y "ABCDEFGH"))

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

Python supporta vari argomenti fantasiosi e argomenti di parole chiave. In Python potremmo
vedere:

>>> def optional_arg(pos1, pos2, keyword1=Nessuno, keyword2=42):
... return [pos1, pos2, parola chiave1, parola chiave2]
...
>>> argomento_facoltativo(1, 2)
[1, 2, Nessuno, 42]
>>> arg_opzionale(1, 2, 3, 4)
[1, 2, 3, 4]
>>> optional_arg(keyword1=1, pos2=2, pos1=3, keyword2=4)
[3, 2, 1, 4]

La stessa cosa in Hy:

=> (defn optional-arg [pos1 pos2 &optional keyword1 [keyword2 42]]
... [pos1 pos2 parola chiave1 parola chiave2])
=> (opzionale-arg 1 2)
[1 2 Nessuno 42]
=> (opzionale-arg 1 2 3 4)
[1 2 3 4]

Se stai eseguendo una versione di Hy precedente alla 0.10.1 (es. git master), c'è anche una bella novità
sintassi dell'argomento della parola chiave:

=> (opzionale-arg :keyword1 1
... :pos2 2
... :pos1 3
... :parola chiave2 4)
[3, 2, 1, 4]

Altrimenti, puoi sempre usare applicare. Ma cosa c'è? applicare?

Hai familiarità con il passaggio? *argomenti ed ** kwargs in Python?:

>>> argomenti = [1 2]
>>> kwargs = {"parola chiave2": 3
... "parola chiave1": 4}
>>> optional_arg(*args, **kwargs)

Possiamo riprodurlo con applicare:

=> (setv argomenti [1 2])
=> (setv kwargs {"parola chiave2" 3
... "parola chiave1" 4})
=> (applica optional-arg args kwargs)
[1, 2, 4, 3]

C'è anche una costruzione di argomenti di parole chiave in stile dizionario che assomiglia a:

(defn un altro stile [&key {"key1" "val1" "key2" "val2"}]
[tasto1 tasto2])

La differenza qui è che poiché è un dizionario, non puoi fare affidamento su nessuno specifico
ordinando agli argomenti.

Hy supporta anche *argomenti ed ** kwargs. In Python:

def some_func(pippo, bar, *args, **kwargs):
importa stampa
pprint.pprint((foo, bar, args, kwargs))

L'equivalente Hy:

(definire alcune funzioni [foo bar &rest args &kwargs kwargs]
(importa stampa)
(pprint.pprint (, foo bar args kwargs)))

Infine, ovviamente, abbiamo bisogno di lezioni! In Python, potremmo avere una classe come:

classe FooBar (oggetto):
"" "
Ancora un altro esempio di classe
"" "
def __init__(self, x):
sé.x = x

def get_x(self):
"" "
Restituisci la nostra copia di x
"" "
restituire self.x

In Hy:

(defclass FooBar [oggetto]
"Ancora un altro esempio di classe"
[[--dentro--
(fn [auto x]
(setv self.xx)
; Attualmente necessario per --init-- perché __init__ necessita di Nessuno
; Speriamo che questo vada via :)
Nessuno)]

[prendi-x
(fn [sé]
"Restituisci la nostra copia di x"
auto.x)]])

Puoi anche fare attributi a livello di classe. In Python:

classe Cliente (modelli.Modello):
name = models.CharField (max_length = 255)
indirizzo = modelli.TextField()
note = modelli.TextField()

In Hy:

(defclass Cliente [models.Model]
[[nome (models.CharField :max-length 255})]
[indirizzo (models.TextField)]
[note (modelli.TextField)]])

Hy <-> Python interoperabilità
Importando Hy, puoi usare Hy direttamente da Python!

Se salvi quanto segue in saluti.hy:

(defn salutare [nome] (stampa "ciao da hy", nome))

Quindi puoi usarlo direttamente da Python, importando hy prima di importare il modulo. In
Pitone:

importa hy
importa saluti

saluti.greet("Più")

Puoi anche dichiarare una funzione in Python (o anche una classe!) e usarla in Hy!

Se salvi quanto segue in saluti.py in pitone:

def salutare (nome):
print("ciao, %s" % (nome))

Puoi usarlo in Hy:

(importazione saluti)
(.saluti "pippo")

Per utilizzare gli argomenti delle parole chiave, puoi usare in saluti.py:

def salutare (nome, titolo = "Signore"):
print("Saluti, %s %s" % (titolo,nome))

(importazione saluti)
(.saluti "Foo")
(.saluti "Foo" "Darth")
(applica (. saluti saluto) ["Pippo"] {"titolo" "Signore"})

Che produrrebbe:

Saluti, Sir Foo

Saluti, Darth Foo

Saluti, Lord Foo

Suggerimenti!
Hy presenta anche qualcosa noto come "macro di threading", una caratteristica davvero accurata di
di Clojure. La "macro di threading" (scritta come ->) viene utilizzato per evitare l'annidamento profondo di
espressioni.

La macro di threading inserisce ogni espressione nel primo argomento dell'espressione successiva
posto.

Prendiamo il classico:

(loop (stampa (eval (leggi))))

Piuttosto che scriverlo in questo modo, possiamo scriverlo come segue:

(-> (leggi) (val) (stampa) (loop))

Ora, usando pitone, possiamo mostrare come la macro di threading (a causa della configurazione di python-sh)
può essere usato come una pipa:

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

Che, ovviamente, si estende a:

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

Molto più leggibile, no? Usa la macro threading!

HY STILE GUIDA

"Sai, ministro, non sono d'accordo con Silente su molti aspetti... ma non puoi negare che sia...
ottenuto stile…” — Phineas Nigellus Black, tormentare Vasaio ed , il Ordina of , il Phoenix

La guida allo stile Hy vuole essere un insieme di regole di base per Hyve (sì, la comunità Hy
è orgoglioso di aggiungere Hy a tutto) per scrivere codice Hy idiomatico. Hy deriva molto
da Clojure & Common Lisp, mantenendo sempre l'interoperabilità di Python.

Preludio
I Tao of Hy
Ummon chiese al capo dei monaci: "Su quale sutra stai tenendo conferenze?"
"Il Nirvana Sutra".
"Il Nirvana Sutra ha le Quattro Virtù, vero?"
"Esso ha."
Ummon chiese, prendendo una tazza, "Quante virtù ha questo?"
"Nessuno", disse il monaco.
"Ma gli antichi dicevano di sì, no?" disse Ummo.
"Cosa ne pensi di quello che hanno detto?"
Ummon colpì la tazza e chiese: "Hai capito?"
"No", disse il monaco.
"Allora", disse Ummon, "farai meglio a continuare con le tue lezioni sul sutra".
— il (koan) macro

Quanto segue illustra un breve elenco di decisioni progettuali che sono andate alla realizzazione di
Hy.

· Aspetto un Lisp; DTRT con esso (ad esempio i trattini si trasformano in trattini bassi, i paraorecchie si trasformano in
tutto maiuscolo).

· Siamo ancora Python. La maggior parte degli interni si traduce 1:1 in interni Python.

· Usa Unicode ovunque.

· Risolvi le decisioni sbagliate in Python 2 quando possiamo (vedi vera_divisione).

· In caso di dubbio, affidati a Python.

· Se non sei ancora sicuro, affidati a Clojure.

· Se sei ancora più insicuro, affidati a Common Lisp.

· Tieni presente che non siamo Clojure. Non siamo Common Lisp. Siamo Homoiconic Python, con
bit in più che hanno un senso.

disposizione & dentellatura
· Evitare spazi finali. fanno schifo!

· Il rientro deve essere di 2 spazi (senza tabulazioni rigide), tranne quando corrisponde al rientro di
la riga precedente.

;; Buono (e preferito)
(def. fib [n]
(se (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2))))))

;; ancora bene
(def. fib [n]
(se (<= n 2) n (+ (fib (- n 1)) (fib (- n 2)))))

;; ancora bene
(def. fib [n]
(se (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2))))))

;; Istericamente ridicolo
(def. fib [n]
(se (<= n 2)
n ;; si, mi piace premere a caso la barra spaziatrice
(+ (fib (- n 1)) (fib (- n 2))))))

· Le parentesi devono mai essere lasciato solo, triste e solitario sulla propria linea.

;; Buono (e preferito)
(def. fib [n]
(se (<= n 2)
n
(+ (fib (- n 1)) (fib (- n 2))))))

;; Istericamente ridicolo
(def. fib [n]
(se (<= n 2)
n
(+ (fibre (- n 1)) (fibre (- n 2)))
)
); GAH, BRUCIALO CON IL FUOCO

· Allinea verticalmente lasciare blocchi.

(lascia [[pippo (bar)]
[qux (baz)]]
(pippo qux))

· I commenti in linea devono essere due spazi dalla fine del codice; devono sempre avere un
spazio tra il carattere del commento e l'inizio del commento. Inoltre, prova a non farlo
commenta l'ovvio.

;; Buono
(setv ind (dec x)) ; l'indicizzazione parte da 0

;; Conforme allo stile ma afferma solo l'ovvio
(setv ind (dec x)) ; imposta l'indice su x-1

;; Male
(setv ind (dec x));digitare parole per divertimento

codifica Style
· Per convenzione, cerca di non usare def per qualsiasi cosa diversa dalle variabili globali; uso setv
funzioni interne, loop, ecc.

;; Buono (e preferito)
(def *limite* 400000)

(def. bugie [ab]
(mentre vero
(produrre a)
(setv (, ab) (, b (+ ab)))))

;; Cattivo (e non preferito)
(def. bugie [ab]
(mentre vero
(produrre a)
(def (, ab) (, b (+ ab)))))

· Non utilizzare la sintassi dell'espressione s laddove è prevista la sintassi vettoriale. Per esempio, il fatto
che il primo di questi due esempi funziona è solo perché il compilatore non è eccessivamente
severa. In realtà, la sintassi corretta in posti come questo è quest'ultima.

;; Cattivo (e cattivo)
(def. pippo (x) (stampa x))
(pippo 1)

;; Buono (e preferito)
(def pippo [x] (stampa x))
(pippo 1)

· Utilizzare la macro di filettatura o le macro di coda di filettatura quando si incontrano annidamenti profondi
s-espressioni. Tuttavia, sii giudizioso quando li usi. Usali quando chiarezza e
la leggibilità migliora; non costruire espressioni contorte e difficili da capire.

;; preferito
(def *nomi*
(con [f (apri "nomi.txt")]
(-> (.leggi f) (.strip) (.sostituisci "\"" "") (.split ",") (ordinato))))

;; Non così buono
(def *nomi*
(con [f (apri "nomi.txt")]
(ordinato (.split "," (.replace "\"" "" (.strip (.read f))))))))

;; Probabilmente non una buona idea
(def. quadrato? [x]
(->> 2 (pow (int (sqrt x))) (= x)))

· La notazione a punti in stile Clojure è preferita alla chiamata diretta del metodo dell'oggetto,
anche se entrambi continueranno a essere supportati.

;; Buono
(con [fd (aperto "/etc/passwd")]
(stampa (.readlines fd)))

;; Non così buono
(con [fd (aperto "/etc/passwd")]
(stampa (fd.readlines)))

Conclusione
“Le mode svaniscono, lo stile è eterno” —Yves Saint Laurent

Questa guida è solo un insieme di linee guida della comunità e, ovviamente, le linee guida della comunità lo fanno
non ha senso senza una comunità attiva. Sono graditi contributi. Unisciti a noi su #hyin
freenode, blog su di esso, tweet su di esso e, soprattutto, divertiti con Hy.

Grazie
· Questa guida è fortemente ispirata da @paultag il post del blog Hy Sopravvivenza Guida

· Il Clojure Style Guida

DOCUMENTAZIONE INDICE

Contenuto:

Comando linea Interfaccia
hy
Comando linea Opzioni
-c
Esegui il codice Hy in command.

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

-i
Esegui il codice Hy in command, quindi rimani in REPL.

-m
Esegui il codice Hy in modulo, Compreso definire se definito.

I -m flag termina l'elenco delle opzioni in modo che tutti gli argomenti dopo il modulo Nome
sono passati al modulo in sys.argv.

Novità nella versione 0.10.2.

--spiare Stampa il codice Python equivalente prima dell'esecuzione. Per esempio:

=> (defn salutinm [nome] (stampa (+ "Hy " nome "!")))
def salutinm(nome):
return print(((u'Hy ' + nome) + u'!'))
=> (salutinm "TuoNome")
salutationsnm(u'TuoNome')
Ciao TuoNome!
=>

Novità nella versione 0.9.11.

--show-traceback
Stampa traceback estesi per le eccezioni Hy.

Novità nella versione 0.9.12.

-v Stampa il numero della versione Hy ed esci.

ciao
Comando linea Opzioni
file[, fileN]
Compila il codice Hy in bytecode Python. Ad esempio, salva il seguente codice come
hyname.hy:

(def hy-hy [nome]
(stampa (+ "Hy " nome "!")))

(hy-hy "afroman")

Quindi eseguire:

$ hyc nomeinno.hy
$ python hyname.pyc
hy afroman!

hy2py
Novità nella versione 0.10.1.

Comando linea Opzioni
-s

--con-fonte
Mostra la struttura di origine analizzata.

-a

--con-ast
Mostra l'AST generato.

-np

--senza-python
Non mostrare il codice Python generato dall'AST.

Hy (la linguaggio)
ATTENZIONE:
Questo è incompleto; si prega di considerare di contribuire allo sforzo di documentazione.

Teoria of Hy
Hy mantiene, sopra ogni altra cosa, la compatibilità al 100% in entrambe le direzioni con Python
si. Tutto il codice Hy segue alcune semplici regole. Memorizza questo, mentre sta per entrare
a portata di mano.

Queste regole aiutano a garantire che il codice Hy sia idiomatico e interfacciabile in entrambe le lingue.

· I simboli negli auricolari verranno tradotti nella versione maiuscola di quella stringa. Per
esempio, foo diventerà FOO.

· Le entità UTF-8 verranno codificate utilizzando codice puny e preceduto da ciao_. Per esempio, ⚘
diventerà hy_w7h, ♥ diventerà hy_g6he io♥ tu diventerà hy_iu_t0x.

· I simboli che contengono trattini verranno sostituiti con trattini bassi. Per esempio,
modello di rendering diventerà modello_render. Ciò significa che i simboli con i trattini lo faranno
ombra i loro equivalenti di sottolineatura e viceversa.

Built-Ins
Hy presenta una serie di moduli speciali che vengono utilizzati per aiutare a generare Python AST corretto.
Le seguenti sono forme "speciali", che possono avere un comportamento leggermente inaspettato in
alcune situazioni.

.
Novità nella versione 0.10.0.

. viene utilizzato per eseguire l'accesso agli attributi sugli oggetti. Utilizza una piccola DSL per consentire un rapido
accesso ad attributi ed elementi in una struttura dati nidificata.

Per esempio,

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

Compila fino a:

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

. compila il suo primo argomento (nell'esempio, foo) come oggetto su cui eseguire il
dereferenziazione degli attributi. Utilizza simboli semplici come attributi per accedere (nell'esempio, bar,
baz, frob), e compila il contenuto delle liste (nell'esempio, [(+ 1 2)]) per l'indicizzazione.
Altri argomenti generano un errore di compilazione.

L'accesso ad attributi sconosciuti genera an AttributoError. L'accesso a chiavi sconosciute genera an
Errore indice (su liste e tuple) o a Errore chiave (su dizionari).

->
-> (O l' threading macro) viene utilizzato per evitare l'annidamento delle espressioni. La macro di filettatura
inserisce ogni espressione nel primo argomento dell'espressione successiva. Il seguente
il codice lo dimostra:

=> (output defn [ab] (stampa ab))
=> (-> (+ 4 6) (uscita 5))
10/5

- >>
- >> (O l' threading coda macro) è simile a threading macro, ma invece di
inserendo ogni espressione nel primo argomento dell'espressione successiva, la aggiunge come
ultimo argomento. Il codice seguente lo dimostra:

=> (output defn [ab] (stampa ab))
=> (->> (+ 4 6) (uscita 5))
5/10

applicare
applicare è usato per applicare un elenco opzionale di argomenti e un dizionario opzionale di kwargs
ad una funzione.

Uso: (applicare fn-nome [argomenti] [kwarg])

Consigli d'uso:

(definito thunk []
"Ehi lì")

(applica thunk)
;=> "ciao là"

(defn acquisto totale [importo prezzo &opzionale [commissioni 1.05] [iva 1.1]]
(* prezzo importo commissioni iva))

(applica acquisto totale [10 15])
;=> 173.25

(applicare l'acquisto totale [10 15] {"vat" 1.05})
;=> 165.375

(applicare l'acquisto totale [] {"prezzo" 10 "importo" 15 "iva" 1.05})
;=> 165.375

ed
ed è usato nelle espressioni logiche. Richiede almeno due parametri. Se tutti i parametri
valutare a I veri, viene restituito l'ultimo parametro. In ogni altro caso, il primo valore falso
verrà restituito. Esempio di utilizzo:

=> (e Vero Falso)
Falso

=> (e Vero Vero)
I veri

=> (e Vero 1)
1

=> (e Vero [] Falso Vero)
[]

NOTA:
ed cortocircuita e interrompe la valutazione dei parametri non appena il primo falso è
incontrato.

=> (e False (stampa "ciao"))
Falso

affermare
affermare viene utilizzato per verificare le condizioni durante l'esecuzione del programma. Se la condizione non è
incontrato, an AsserzioneErrore viene sollevato. affermare può richiedere uno o due parametri. Il primo
parametro è la condizione da verificare e dovrebbe essere valutata su entrambi I veri or Falso.
il secondo parametro, facoltativo, è un'etichetta per l'asserzione ed è la stringa che sarà
cresciuto con il AsserzioneErrore. Per esempio:

(asser (= valore atteso variabile))

(affermare Falso)
; AsserzioneErrore

(asser (= 1 2) "uno dovrebbe essere uguale a due")
; AssertionError: uno dovrebbe essere uguale a due

Assoc
Assoc si usa per associare una chiave ad un valore in un dizionario o per impostare un indice di una lista
ad un valore. Richiede almeno tre parametri: il dati La struttura da modificare, a chiave
or Index, e un APPREZZIAMO. Se vengono utilizzati più di tre parametri, verrà associato a coppie.

Esempi di utilizzo:

=>(lascia [[raccolta {}]]
... (collezione assoc "Cane" "Bark")
... (raccolta di stampe))
{u'Dog': u'Bark'}

=>(lascia [[raccolta {}]]
... (collezione assoc "Cane" "Bark" "Cat" "Meow")
... (raccolta di stampe))
{u'Cat': u'Meow', u'Dog': u'Bark'}

=>(let [[raccolta [1 2 3 4]]]
... (collezione assoc 2 Nessuno)
... (raccolta di stampe))
[1, 2, Nessuno, 4]

NOTA:
Assoc modifica la struttura dati in atto e restituisce Nessuna.

rompere
rompere è usato per uscire da un ciclo. Termina immediatamente il ciclo. Il seguente
l'esempio ha un infinito while ciclo che viene terminato non appena l'utente entra k.

(mentre True (if (= "k" (input non elaborato "? "))
(rottura)
(stampa "Riprova")))

cond
cond può essere usato per costruire annidato if dichiarazioni. L'esempio seguente mostra il
relazione tra la macro e la sua espansione:

(cond [condizione-1 risultato-1]
[condizione-2 risultato-2])

(se condizione-1 risultato-1
(se condizione-2 risultato-2))

Come mostrato di seguito, viene eseguito solo il primo blocco di risultati corrispondenti.

=> (def. check-value [valore]
... (cond [(< valore 5) (print "il valore è minore di 5")]
... [(= valore 5) (stampa "il valore è uguale a 5")]
... [(> valore 5) (stampa "il valore è maggiore di 5")]
... [Vero (stampa "il valore è qualcosa che non dovrebbe essere")]))

=> (valore di controllo 6)
il valore è maggiore di 5

continua
continua restituisce l'esecuzione all'inizio di un ciclo. Nel seguente esempio,
(effetto collaterale1) viene chiamato per ogni iterazione. (effetto collaterale2), tuttavia, è solo chiamato
ogni altro valore nell'elenco.

;; assumendo che (effetto collaterale1) e (effetto collaterale2) siano funzioni e
;; la raccolta è una lista di valori numerici

(per [x collezione]
(di
(effetto collaterale1 x)
(se (% x 2)
(Continua))
(effetto collaterale2 x)))

dict-comp
dict-comp viene utilizzato per creare dizionari. Occorrono tre o quattro parametri. Il primo
due parametri servono per controllare il valore restituito (coppia chiave-valore) mentre il terzo è
utilizzato per selezionare elementi da una sequenza. Il quarto e facoltativo parametro può essere utilizzato per
filtrare alcuni degli elementi nella sequenza in base a un'espressione condizionale.

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

do / programma
do ed programma sono usati per valutare ciascuno dei loro argomenti e restituire l'ultimo. Ritorno
i valori da ogni altro argomento diverso dall'ultimo vengono scartati. Può essere utilizzato in lambda or
lista-comp per eseguire una logica più complessa come mostrato in uno degli esempi seguenti.

Alcuni esempi di utilizzo:

=> (se vero
... (fai (stampa "Rock degli effetti collaterali!")
... (stampa "Sì, davvero!")))
Effetti collaterali rock!
Sì davvero!

;; supponendo che (effetto collaterale) sia una funzione che vogliamo chiamare per ciascuno
;; e ogni valore nell'elenco, ma il cui valore di ritorno non ci interessa
=> (list-comp (do (effetto collaterale x)
... (se (< x 5) (* 2 x)
... (* 4 x)))
... (x (intervallo 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do può accettare un numero qualsiasi di argomenti, da 1 a n.

def / setv
def ed setv sono usati per associare un valore, un oggetto o una funzione a un simbolo. Per esempio:

=> (def nomi ["Alice" "Bob" "Charlie"])
=> (stampa nomi)
[u'Alice', u'Bob', u'Charlie']

=> (setv counter (fn [collection item] (.count collection item)))
=> (contatore [1 2 3 4 5 2 3] 2)
2

defclass
Le nuove classi sono dichiarate con defclass. Può richiedere due parametri opzionali: un vettore
definendo una possibile superclasse e un altro vettore contenente gli attributi del nuovo
classe come vettori di due elementi.

(defclass nome-classe [super-class-1 super-class-2]
[[valore attributo]])

Sia i valori che le funzioni possono essere associati alla nuova classe come mostrato nell'esempio seguente:

=> (declassa Gatto []
... [[età Nessuna]
... [colore "bianco"]
... [parla (fn [self] (print "Meow"))]])

=> (punto predefinito (Cat))
=> (setv spot.colore "Nero")
'Nero'
=> (.parlare spot)
Miao

def / defunto
def ed defunto le macro vengono utilizzate per definire le funzioni. Prendono tre parametri: il Nome
della funzione da definire, un vettore di parametri, e il stile di vita della funzione:

(nome defn [params] corpo)

I parametri possono avere le seguenti parole chiave davanti a loro:

&opzionale
Il parametro è facoltativo. Il parametro può essere dato come un elenco di due voci, dove il
il primo elemento è il nome del parametro e il secondo è il valore predefinito. Il parametro
può essere fornito anche come elemento singolo, nel qual caso il valore predefinito è Nessuna.

=> (defn valore totale [valore &opzionale [imposta sul valore aggiunto 10]]
... (+ (/ (* valore IVA) 100) valore))

=> (valore totale 100)
110.0

=> (valore totale 100 1)
101.0

&chiave

&kwargs
Il parametro conterrà 0 o più argomenti di parole chiave.

I seguenti esempi di codice definiscono una funzione che stamperà tutte le parole chiave
argomenti e i loro valori.

=> (defn print-parameters [&kwargs kwargs]
... (per [(, kv) (.items kwargs)] (stampa kv)))

=> (applica i parametri di stampa [] {"parametro-1" 1 "parametro-2" 2})
parametro-2 2
parametro-1 1

&riposo Il parametro conterrà 0 o più argomenti posizionali. Nessun altro posizionale
gli argomenti possono essere specificati dopo questo.

Il seguente esempio di codice definisce una funzione che può essere assegnata da 0 a n numerica
parametri. Quindi somma ogni numero dispari e sottrae ogni numero pari.

=> (defn somma a zig-zag [&rest numeri]
(let [[numeri-dispari (lista-comp x [x numeri] (dispari? x))]
[numeri pari (lista-comp x [x numeri] (pari? x))]]
(- (somma numeri dispari) (somma numeri pari))))

=> (somma a zig-zag)
0
=> (somma a zig-zag 3 9 4)
8
=> (somma a zig-zag 1 2 3 4 5 6)
-3

defn-alias / defun-alias
Novità nella versione 0.10.0.

I defn-alias ed defun-alias le macro sono molto simili def, con la distinzione che
invece di definire una funzione con un solo nome, possono anche definire alias. Altro
piuttosto che prendere un elenco di simboli per i nomi delle funzioni come primo parametro, defn-alias ed
defun-alias non sono diversi da def ed defunto.

=> (alias defn [alias nome principale] []
... (stampa "Ciao!"))
=> (nome principale)
"Ciao!"
=> (alias)
"Ciao!"

definire
Novità nella versione 0.10.1.

I definire macro definisce una funzione principale che viene immediatamente chiamata con sys.argv as
argomenti se e solo se questo file viene eseguito come script. In altre parole, questo:

(defmain [&rest args]
(fare-qualcosa-con argomenti))

è l'equivalente di:

def principale(*argomenti):
fare_qualcosa_con(argomenti)
ritorna 0

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

se istanza(retval, int):
sys.exit(recupero)

Nota che come puoi vedere sopra, se restituisci un numero intero da questa funzione, questo sarà
utilizzato come stato di uscita per il tuo script. (Python per impostazione predefinita esce dallo stato 0 altrimenti,
il che significa che va tutto bene!)

(Da (sys.exit 0) non viene eseguito esplicitamente nel caso di un ritorno non intero da
definire, è una buona idea mettere (definire) come l'ultimo pezzo di codice nel tuo file.)

defmacro
defmacro viene utilizzato per definire le macro. Il formato generale è (defmacro Nome [parametri]
espr).

L'esempio seguente definisce una macro che può essere utilizzata per scambiare l'ordine degli elementi nel codice,
consentendo all'utente di scrivere codice in notazione infissa, dove l'operatore è tra i
operandi.

=> (defmacro infisso [codice]
... (quasi virgoletta (
... (togliere virgolette (ottenere il codice 1))
... (togliere virgolette (ottenere il codice 0))
... (elimina le virgolette (ottieni il codice 2)))))

=> (infisso (1 + 1))
2

defmacro alias
defmacro alias viene utilizzato per definire macro con più nomi (alias). Il formato generale
is (defmacro alias [nomi] [parametri] espr). Crea più macro con lo stesso
elenco di parametri e corpo, sotto l'elenco di nomi specificato.

L'esempio seguente definisce due macro, che consentono entrambe all'utente di scrivere codice in
notazione infissa.

=> (defmacro-alias [infisso infi] [codice]
... (quasi virgoletta (
... (togliere virgolette (ottenere il codice 1))
... (togliere virgolette (ottenere il codice 0))
... (elimina le virgolette (ottieni il codice 2)))))

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

defmacro/g!
Novità nella versione 0.9.12.

defmacro/g! è una versione speciale di defmacro che viene utilizzato per generare automaticamente gensim
per qualsiasi simbolo che inizia con g!.

Per esempio, g! a potrebbe diventare (gensim "un").

VEDERE INOLTRE:
Sezione using-gensym

deflettore
Novità nella versione 0.9.12.

deflettore definisce una macro del lettore, che consente di ristrutturare o modificare la sintassi.

=> (defreader ^ [espr] (stampa espr))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Ciao"
"Ciao"

VEDERE INOLTRE:
Macro del lettore di sezioni

del
Novità nella versione 0.9.12.

del rimuove un oggetto dallo spazio dei nomi corrente.

=> (setv pippo 42)
=> (del pippo)
=> pippo
Traceback (ultima chiamata più recente):
File " ", riga 1, in
NameError: il nome 'pippo' non è definito

del può anche rimuovere oggetti da mappature, elenchi e altro.

=> (test setv (elenco (intervallo 10)))
=> prova
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (del (prova sezione 2 4)) ;; rimuovi gli elementi da 2 a 4 esclusi
=> prova
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"pippo" "bar"})
=> dic
{"pippo": "bar"}
=> (del (ottieni dic "pippo"))
=> dic
{}

a
Novità nella versione 0.10.1.

a viene utilizzato per semplificare una sequenza di chiamate di metodo a un oggetto.

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

=> (raccolta setv [])
=> (.append raccolta 1)
=> (.append raccolta 2)
=> (.raccolta inversa)
=> collezione
[2 1]

eval
eval valuta un'espressione tra virgolette e restituisce il valore.

=> (eval '(print "Hello World"))
"Ciao mondo"

valuta-e-compila
eval-quando-compila
prima di tutto / auto
prima di tutto ed auto sono macro per accedere al primo elemento di una collezione:

=> (primo (intervallo 10))
0

per
per è usato per chiamare una funzione per ogni elemento in una lista o in un vettore. I risultati di ogni
chiamata vengono scartati e il per l'espressione restituisce Nessuna invece. Il codice di esempio itera
ancora collezione e per ciascuno elemento in collezione chiama il effetto collaterale funzione con
elemento come suo argomento:

;; supponendo che (effetto collaterale) sia una funzione che accetta un singolo parametro
(per [raccolta elementi] (elemento effetto collaterale))

;; per può avere un blocco else opzionale
(per [raccolta elementi] (elemento effetto collaterale)
(altro (effetto collaterale-2)))

Facoltativo altro blocco viene eseguito solo se il per il ciclo termina normalmente. Se la
l'esecuzione viene interrotta con rompere, le altro blocco non viene eseguito.

=> (per [elemento [1 2 3]] (se (< elemento 3)
... (elemento di stampa)
... (rottura))
... (altrimenti (stampa "ciclo terminato")))
1
2

=> (per [elemento [1 2 3]] (se (< elemento 4)
... (elemento di stampa)
... (rottura))
... (altrimenti (stampa "ciclo terminato")))
1
2
3
ciclo finito

geneexpr
geneexpr viene utilizzato per creare espressioni generatore. Ci vogliono due o tre parametri. Il
il primo parametro è l'espressione che controlla il valore restituito, mentre il secondo è usato
per selezionare elementi da un elenco. Il terzo e facoltativo parametro può essere utilizzato per filtrare
alcuni degli elementi nell'elenco in base a un'espressione condizionale. geneexpr è simile
lista-comp, tranne per il fatto che restituisce un iterabile che valuta i valori uno per uno invece di
valutandoli immediatamente.

=> (raccolta def (intervallo 10))
=> (def filtrato (genexpr x [x collection] (even? x)))
=> (lista filtrata)
[0, 2, 4, 6, 8]

gensim
Novità nella versione 0.9.12.

gensim viene utilizzato per generare un simbolo univoco che consente di scrivere macro senza
conflitti accidentali di nomi di variabili.

=> (gensim)
u':G_1235'

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

VEDERE INOLTRE:
Sezione using-gensym

ottenere
ottenere viene utilizzato per accedere a singoli elementi in elenchi e dizionari. ottenere accetta due parametri:
, il dati La struttura e la Index or chiave dell'oggetto. Quindi restituirà il corrispondente
valore dal dizionario o dall'elenco. Esempio di utilizzo:

=> (lascia [[animali {"cane" "abbaia" "gatto" "miagola"}]
... [numeri ["zero" "uno" "due" "tre"]]]
... (stampa (ottieni animali "cane"))
... (stampa (ottieni numeri 2)))
corteccia
seconda

NOTA:
ottenere solleva un KeyError se un dizionario viene interrogato per una chiave inesistente.

NOTA:
ottenere solleva un IndexError se una lista o una tupla viene interrogata per un indice che è fuori
limiti.

globale
globale può essere utilizzato per contrassegnare un simbolo come globale. Ciò consente al programmatore di assegnare a
valore a un simbolo globale. La lettura di un simbolo globale non richiede il globale parola chiave --
solo assegnarlo lo fa.

L'esempio seguente mostra come il simbolo globale a viene assegnato un valore in una funzione e
viene successivamente stampato in un'altra funzione. Senza il globale parola chiave, la seconda funzione
avrebbe gettato a NomeErrore.

(def set-a [valore]
(globale a)
(imposta un valore))

(def stampa-a []
(stampa a))

(set-a 5)
(stampa-a)

if / altrimenti
Novità nella versione 0.10.0: if-not

if viene utilizzato per selezionare in modo condizionale il codice da eseguire. Deve contenere una condizione
blocco e il blocco da eseguire se il blocco della condizione restituisce I veri. Facoltativamente,
può contenere un blocco finale che viene eseguito nel caso in cui la valutazione della condizione sia
Falso.

altrimenti è simile, ma il secondo blocco verrà eseguito quando la condizione fallisce while
il terzo e ultimo blocco viene eseguito quando il test ha esito positivo -- l'ordine opposto di if.

Utilizzo di esempio:

(se (soldi rimasti? conto)
(stampa "andiamo a fare shopping")
(stampa "andiamo a lavorare"))

(se-no (soldi rimasti? conto)
(stampa "andiamo a lavorare")
(stampa "andiamo a fare shopping"))

La veridicità di Python è rispettata. Nessuna, Falso, zero di qualsiasi tipo numerico, una sequenza vuota,
e un dizionario vuoto sono considerati Falso; tutto il resto è considerato I veri.

lisp-se / LIF ed lisp-se-non / senza vita
Novità nella versione 0.10.0.

Novità nella versione 0.10.2: lisp-if-not / lif-not

Per coloro che preferiscono un più Lispy if clausola, abbiamo lisp-se, o LIF. Questo esclusivamente ritiene
Nessuna / zero essere falso! Tutti gli altri valori Python "falsi" sono considerati veri.
Al contrario, abbiamo lisp-se-non ed senza vita in parallelo a if ed altrimenti che inverte
il confronto.

=> (lisp-if True "true" "false")
"vero"
=> (lisp-if False "true" "false")
"vero"
=> (lisp-if 0 "true" "false")
"vero"
=> (lisp-if nil "true" "false")
"falso"
=> (lisp-if None "true" "false")
"falso"
=> (lisp-if-not nil "true" "false")
"vero"
=> (lisp-if-not Nessuno "vero" "falso")
"vero"
=> (lisp-if-not False "true" "false")
"falso"

; Equivalente ma più breve
=> (lif True "true" "false")
"vero"
=> (lif nil "vero" "falso")
"falso"
=> (lif-not Nessuno "vero" "falso")
"vero"

importare
importare è usato per importare moduli, come in Python. Ci sono diversi modi in cui importare può
essere usato.

;; Importa ciascuno di questi moduli
;;
;; Pitone:
;; sistema di importazione
;; importa os.path
(importazione sys os.path)

;; Importa da un modulo
;;
;; Python: da os.path import esiste, isdir, isfile
(import [os.path [esiste isdir isfile]])

;; Importa con un alias
;;
;; Python: importa sys come systest
(importa [sys :as systest])

;; Puoi elencare tutte le importazioni che desideri di diversi tipi.
(importa [tests.resources [kwtest function-with-a-dash]]
[os.path [esiste isdir isfile]]
[sys: come systest])

;; Importa tutte le funzioni del modulo nello spazio dei nomi corrente
(importa [sys [*]])

lambda / fn
lambda ed fn può essere utilizzato per definire una funzione anonima. I parametri sono simili a
def: il primo parametro è vettore di parametri e il resto è il corpo del
funzione. lambda restituisce una nuova funzione. Nell'esempio seguente, una funzione anonima
è definito e passato a un'altra funzione per filtrare l'output.

=> (def persone [{:nome "Alice" :età 20}
... {:nome "Bob" :età 25}
... {:nome "Charlie" :età 50}
... {:name "Dave" :age 5}])

=> (def display-persone [filtro persone]
... (per [persona persone] (if (filtro persona) (stampa (:nome persona)))))

=> (display-persone persone (fn [persona] (< (:età persona) 25)))
Alice
Dave

Proprio come nelle normali definizioni di funzione, se il primo elemento del corpo è una stringa, esso
funge da docstring. Questo è utile per fornire docstring ai metodi di classe.

=> (setv volte-tre
... (fn [x]
... "Moltiplica l'input per tre e restituisce il risultato."
... (* x 3)))

Questo può essere confermato tramite il built-in di Python Aiuto funzione:

=> (aiuto volte-tre)
Aiuto sulla funzione times_three:

volte_tre(x)
Moltiplica l'input per tre e restituisce il risultato
(FINE)

ultimo
Novità nella versione 0.10.2.

ultimo può essere utilizzato per accedere all'ultimo elemento di una raccolta:

=> (ultimo [2 4 6])
6

lasciare
lasciare viene utilizzato per creare variabili con ambito lessicale. Vengono creati all'inizio del
lasciare forma e cessano di esistere dopo la forma. Il seguente esempio mostra questo
comportamento:

=> (lascia [[x 5]] (stampa x)
... (lascia [[x 6]] (stampa x))
... (stampa x))
5
6
5

I lasciare macro accetta due parametri: un vettore che definisce variabili e la stile di vita che ottiene
eseguito. variabili è un vettore in cui ogni elemento è una singola variabile o un vettore
definizione di una coppia di valori variabili. Nel caso di una singola variabile, viene assegnato un valore
Nessuna; in caso contrario, viene utilizzato il valore fornito.

=> (let [x [y 5]] (stampa xy))
Nessuna 5

lista-comp
lista-comp esegue la comprensione delle liste. Ci vogliono due o tre parametri. Il primo
parametro è l'espressione che controlla il valore restituito, mentre il secondo è usato per
selezionare elementi da un elenco. Il terzo e facoltativo parametro può essere utilizzato per filtrare alcuni
degli elementi nell'elenco in base a un'espressione condizionale. Qualche esempio:

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

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

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

non
non è usato nelle espressioni logiche. Prende un singolo parametro e restituisce un invertito
valore di verità. Se I veri è dato come parametro, Falso verrà restituito e viceversa.
Utilizzo di esempio:

=> (non vero)
Falso

=> (non falso)
I veri

=> (non nessuno)
I veri

or
or è usato nelle espressioni logiche. Richiede almeno due parametri. Restituirà il
primo parametro non falso. Se tale valore non esiste, verrà restituito l'ultimo parametro.

=> (o Vero Falso)
I veri

=> (e Falso Falso)
Falso

=> (e Falso 1 Vero Falso)
1

NOTA:
or cortocircuita e interrompe la valutazione dei parametri non appena il primo valore vero è
incontrato.

=> (o True (stampa "ciao"))
I veri

stampare
stampare viene utilizzato per l'output sullo schermo. Esempio di utilizzo:

(stampa "Ciao mondo!")

NOTA:
stampare ritorna sempre Nessuna.

quasicitazione
quasicitazione permette di citare un modulo, ma anche di valutare selettivamente le espressioni.
Espressioni all'interno di a quasicitazione può essere valutato selettivamente usando chiudere le virgolette (~). Il
la forma valutata può anche essere giuntata usando giunzione senza virgolette (~@). Quasicitato può essere anche
scritto usando la virgoletta (`) simbolo.

;; sia `qux' una variabile con valore (bar baz)
`(pippo ~qux)
; equivalente a '(foo (bar baz))
`(pippo ~@qux)
; equivalente a '(foo bar baz)

citare
citare restituisce il modulo passato senza valutarlo. citare può in alternativa essere
scritto usando l'apostrofo (') simbolo.

=> (setv x '(stampa "Hello World"))
; la variabile x è impostata su espressione e non valutata
=> x
(stampa' u'Hello World')
=> (val x)
Ciao a tutti

richiedere
richiedere viene utilizzato per importare macro da un determinato modulo. Ci vuole almeno un parametro
specificando il modulo quali macro devono essere importate. È possibile importare più moduli
con un singolo richiedere.

L'esempio seguente importerà macro da modulo-1 ed modulo-2:

(richiede modulo-1 modulo-2)

riposo / cdr
riposo ed cdr restituisce la raccolta passata come argomento senza il primo elemento:

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

set-comp
set-comp viene utilizzato per creare set. Ci vogliono due o tre parametri. Il primo parametro è
per controllare il valore di ritorno, mentre il secondo viene utilizzato per selezionare elementi da a
sequenza. Il terzo e facoltativo parametro può essere utilizzato per filtrare alcuni degli elementi in
la sequenza basata su un'espressione condizionale.

=> (imposta dati [1 2 3 4 5 2 3 4 5 3 4 5])
=> (set-comp x [x dati] (dispari? x))
{1, 3, 5}

fetta
fetta può essere utilizzato per prendere un sottoinsieme di un elenco e creare un nuovo elenco da esso. Il modulo
accetta almeno un parametro che specifica l'elenco da affettare. Due parametri opzionali possono essere
usato per dare la posizione iniziale e finale del sottoinsieme. Se non vengono forniti, il
valore predefinito di Nessuna verrà invece utilizzato. Il terzo parametro opzionale viene utilizzato per
passo di controllo tra gli elementi.

fetta segue le stesse regole della sua controparte Python. Gli indici negativi vengono contati
a partire dalla fine dell'elenco. Alcuni esempi di utilizzo:

=> (raccolta def (intervallo 10))

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

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

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

=> (raccolta fette 2 8 2)
[2, 4, 6]

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

gettare / aumentare
I gettare or aumentare le forme possono essere utilizzate per sollevare an Eccezione in fase di esecuzione. Esempio di utilizzo:

(gettare)
; rilanciare l'ultima eccezione

(lancia IOError)
; Lancia un IOError

(lancio (IOError "foobar"))
; Lancia un IOError ("foobar")

gettare può accettare un singolo argomento (an Eccezione classe o istanza) o nessun argomento per
rilanciare l'ultimo Eccezione.

prova
I prova il modulo è usato per iniziare a prova / prendere bloccare. Il modulo viene utilizzato come segue:

(provare
(funzione soggetta a errori)
(catch [e ZeroDivisionError] (print "Divisione per zero"))
(altrimenti (stampa "nessun errore"))
(finalmente (stampa "tutto fatto")))

prova deve contenere almeno uno prendere blocco e può facoltativamente includere an altro or infine
bloccare. Se viene generato un errore con un blocco catch corrispondente durante l'esecuzione di
funzione soggetta a errori, quella prendere blocco verrà eseguito. Se non vengono generati errori, il altro
blocco viene eseguito. Il infine blocco verrà eseguito per ultimo indipendentemente dal fatto che sia o meno un
errore è stato sollevato.

salvo che
I salvo che macro è una scorciatoia per scrivere an if dichiarazione che verifica se il dato
il condizionale è Falso. Di seguito viene illustrata l'espansione di questa macro.

(salvo dichiarazione condizionale)

(se condizionale
Nessuna
(fare una dichiarazione))

chiudere le virgolette
All'interno di una forma quasi citata, chiudere le virgolette forza la valutazione di un simbolo. chiudere le virgolette è alias a
la tilde (~) simbolo.

(def. nome "Coccole")
(quasiquote (= nome (nome tra virgolette)))
;=> (u'='u'nome'u'Coccole')

`(= nome ~nome)
;=> (u'='u'nome'u'Coccole')

giunzione senza virgolette
giunzione senza virgolette forza la valutazione di un simbolo all'interno di una forma quasi citata, proprio come
chiudere le virgolette. giunzione senza virgolette può essere utilizzato solo quando il simbolo non quotato contiene un
valore iterabile, poiché "unisce" quell'iterabile nella forma quasi citata. giunzione senza virgolette is
alias al ~@ simbolo.

(def numeri [1 2 3 4])
(quasiquote (+ (numeri di giunzione senza virgolette)))
;=> (u'+' 1L 2L 3L 4L)

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

quando
quando è simile salvo che, tranne che verifica quando il condizionale dato è I veri. Non è
possibile avere un altro blocco in a quando macro. Quanto segue mostra l'espansione di
macro.

(quando dichiarazione condizionale)

(se condizionale (fare istruzione))

while
while viene utilizzato per eseguire uno o più blocchi purché sia ​​soddisfatta una condizione. Il seguente
esempio produrrà "Hello world!" sullo schermo a tempo indeterminato:

(mentre True (stampa "Hello world!"))

con
con viene utilizzato per avvolgere l'esecuzione di un blocco all'interno di un gestore di contesto. Il contesto
manager può quindi impostare il sistema locale e abbatterlo in modo controllato. Il
esempio archetipico di utilizzo con è durante l'elaborazione dei file. con può legare il contesto ad an
argomento o ignorarlo completamente, come mostrato di seguito:

(con [[arg (espr)]] blocco)

(con [[(expr)]] blocco)

(con [[arg (espr)] [(espr)]] blocco)

Il seguente esempio aprirà il NEWS file e stamparne il contenuto sullo schermo. Il
il file viene chiuso automaticamente dopo essere stato elaborato.

(con [[f (apri "NEWS")]] (stampa (.leggi f)))

con-decoratore
con-decoratore è usato per avvolgere una funzione con un'altra. La funzione che svolge il
la decorazione dovrebbe accettare un unico valore: la funzione da decorare e restituire un nuovo
funzione. con-decoratore richiede un minimo di due parametri: la funzione che esegue
decorazione e la funzione da decorare. Può essere più di una funzione di decoratore
applicato; saranno applicati in ordine dal più esterno al più interno, ad es. il primo
decoratore sarà quello più esterno, e così via. I decoratori con argomenti sono chiamati just
come una chiamata di funzione.

(con-decoratore decoratore-divertimento
(definire alcune funzioni [] ...)

(con-decoratore decoratore1 decoratore2 ...
(definire alcune funzioni [] ...)

(con-decoratore (decoratore arg) ..
(definire alcune funzioni [] ...)

Nel seguente esempio, inc-decoratore è usato per decorare la funzione aggiunta con una
funzione che accetta due parametri e chiama la funzione decorata con valori che sono
incrementato di 1. Quando il decorato aggiunta viene chiamato con i valori 1 e 1, la fine
il risultato sarà 4 (1 + 1 + 1 + 1 ).

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

=> (con-decoratore inc-decoratore (defn addizione [ab] (+ ab)))
=> (aggiunta 1 1)
4
=> (con-decoratore inc2-decoratore inc-decoratore
... (addizione defn [ab] (+ ab)))
=> (aggiunta 1 1)
8

con-gensyms
Novità nella versione 0.9.12.

con-gensym viene utilizzato per generare un insieme di gensim per l'uso in una macro. Il seguente codice:

(con-gensyms [abc]
...)

si espande a:

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

VEDERE INOLTRE:
Sezione using-gensym

dare la precedenza
dare la precedenza viene utilizzato per creare un oggetto generatore che restituisce uno o più valori. il generatore
è iterabile e quindi può essere utilizzato in cicli, comprensioni di elenchi e altri simili
costruisce.

La funzione numeri-casuali mostra come i generatori possono essere usati per generare serie infinite
senza consumare una quantità infinita di memoria.

=> (defn moltiplica [basi coefficienti]
... (per [[(, coefficiente di base) (coefficienti di base zip)]]
... (resa (* coefficiente base))))

=> (moltiplicazione (intervallo 5) (intervallo 5))


=> (valore lista-comp [valore (moltiplicazione (intervallo 10) (intervallo 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (importazione casuale)
=> (definire numeri casuali [basso alto]
... (mentre True (rendimento (.randint casuale basso alto))))
=> (lista-comp x [x (prendi 15 (numeri casuali 1 50))])])
[7, 41, 6, 22, 32, 17, 5, 38, 18, 38, 17, 14, 23, 23, 19]

rendimento da
Novità nella versione 0.9.13.

PITONE 3.3 E UP SOLO!

rendimento da è usato per chiamare un sottogeneratore. Questo è utile se vuoi che la tua coroutine
essere in grado di delegare i suoi processi a un'altra coroutine, ad esempio, se si utilizza qualcosa di stravagante come
asincio.

Hy Nucleo
Nucleo funzioni
ultimo
Uso: (ma ultimo colle)

Restituisce un iteratore di tutti tranne l'ultimo elemento in Coll.

=> (elenco (ultimo (intervallo 10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8]

=> (elenco (ultimo [1]))
[]

=> (elenco (ultimo []))
[]

=> (importa itertools)
=> (lista (prendi 5 (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

colle?
Novità nella versione 0.10.0.

Uso: (col? x)

Reso I veri if x è iterabile e non una stringa.

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

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

=> (coll? "abc")
Falso

cons
Novità nella versione 0.10.0.

Uso: (contro a b)

Restituisce una nuova cella contro con auto a e cdr b.

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

=> (= 'hd (auto a))
I veri

=> (= 'tl (cdr a))
I veri

idioti?
Novità nella versione 0.10.0.

Uso: (contro? pippo)

Controlla se foo è una cella contro.

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

=> (contro? a)
I veri

=> (contro? zero)
Falso

=> (contro? [1 2 3])
Falso

dicembre
Uso: (dicembre x)

Restituisce uno in meno di x. Equivalente a (- x 1). aumenta Digitare Errore if Non sei (numerico? X)).

=> (dicembre 3)
2

=> (dicembre 0)
-1

=> (dicembre 12.3)
11.3

smontare
Novità nella versione 0.10.0.

Uso: (smontare albero &opzionale [codice falso])

Scarica l'AST di Python per un dato Hy albero all'uscita standard. Se codice is I veri, la funzione
stampa invece il codice Python.

=> (smonta '(stampa "Hello World!"))
Modulo(
corpo=[
Expr(value=Call(func=Name(id='print'), args=[Str(s='Hello World!')], keywords=[], starargs=Nessuno, kwargs=Nessuno))])

=> (disassembla '(print "Hello World!") true)
print('Ciao mondo!')

vuoto?
Uso: (vuoto? colle)

Reso I veri if Coll è vuoto. Equivalente a (= 0 (soltanto colle)).

=> (vuoto? [])
I veri

=> (vuoto? "")
I veri

=> (vuoto? (, 1 2))
Falso

ogni?
Novità nella versione 0.10.0.

Uso: (ogni? pred colle)

Reso I veri if (precedentemente x) è logico vero per ogni x in Coll, Altrimenti Falso. Ritorno I veri
if Coll è vuoto.

=> (ogni? pari? [2 4 6])
I veri

=> (ogni? pari? [1 3 5])
Falso

=> (ogni? pari? [2 4 5])
Falso

=> (ogni? pari? [])
I veri

galleggiante?
Uso: (galleggiante? x)

Reso I veri if x è un galleggiante.

=> (galleggiante? 3.2)
I veri

=> (galleggiante? -2)
Falso

Anche?
Uso: (Anche? x)

Reso I veri if x è anche. aumenta Digitare Errore if Non sei (numerico? X)).

=> (anche? 2)
I veri

=> (anche? 13)
Falso

=> (anche? 0)
I veri

identità
Uso: (identità x)

Restituisce l'argomento fornito alla funzione.

=> (identità 4)
4

=> (elenco (identità mappa [1 2 3 4]))
[1 2 3 4]

inc
Uso: (inc x)

Restituisce uno in più di x. Equivalente a (+ x 1). aumenta Digitare Errore if Non sei (numerico? X)).

=> (inc 3)
4

=> (inc 0)
1

=> (inc 12.3)
13.3

esempio?
Uso: (esempio? classe x)

Reso I veri if x è un'istanza di classe.

=> (istanza? float 1.0)
I veri

=> (istanza? int 7)
I veri

=> (istanza? str (str "pippo"))
I veri

=> (defclass TestClass [oggetto])
=> (setv inst (TestClass))
=> (istanza? TestClass inst)
I veri

numero intero?
Uso: (numero intero? x)

Reso I veri if x è un numero intero. Per Python 2, questo è o int or lungo. Per Python 3,
questo è int.

=> (intero? 3)
I veri

=> (intero? -2.4)
Falso

intercalare
Novità nella versione 0.10.1.

Uso: (interlacciare seq.1 seq.2 ...)

Restituisce un iterabile del primo elemento in ciascuna delle sequenze, quindi il secondo, ecc.

=> (elenco (intervallo (intervallo 5) (intervallo 100 105)))
[0, 100, 1, 101, 2, 102, 3, 103, 4, 104]

=> (lista (interfoliazione (intervallo 1000000) "abc"))
[0, 'a', 1, 'b', 2, 'c']

interporre
Novità nella versione 0.10.1.

Uso: (interporre articolo seg.)

Restituisce un iterabile degli elementi della sequenza separati dall'elemento.

=> (lista (interponi "!" "abcd"))
['a', '!', 'b', '!', 'c', '!', 'd']

=> (lista (interponi -1 (intervallo 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

iterabile?
Uso: (iterabile? x)

Reso I veri if x è iterabile. Gli oggetti iterabili restituiscono un nuovo iteratore quando (it x) is
chiamato. Contrasto con iteratore?.

=> ;; funziona per le stringhe
=> (iterabile? (str "abcde"))
I veri

=> ;; funziona per le liste
=> (iterabile? [1 2 3 4 5])
I veri

=> ;; funziona per le tuple
=> (iterabile? (, 1 2 3))
I veri

=> ;; lavora per dicts
=> (iterabile? {:a 1 :b 2 :c 3})
I veri

=> ;; funziona per iteratori/generatori
=> (iterabile? (ripeti 3))
I veri

iteratore?
Uso: (iteratore? x)

Reso I veri if x è un iteratore. Gli iteratori sono oggetti che si restituiscono come
iteratore quando (it x) è chiamato. Contrasto con iterabile?.

=> ;; non funziona per una lista
=> (iteratore? [1 2 3 4 5])
Falso

=> ;; ma possiamo ottenere un iter dalla lista
=> (iteratore? (iter [1 2 3 4 5]))
I veri

=> ;; non funziona per dict
=> (iteratore? {:a 1 :b 2 :c 3})
Falso

=> ;; creare un iteratore dal dict
=> (iteratore? (iter {:a 1 :b 2 :c 3}))
I veri

elenco*
Uso: (elenco* capo &riposo coda)

Genera una catena di celle contro nidificate (un elenco punteggiato) contenente gli argomenti. Se la
l'elenco di argomenti ha solo un elemento, restituiscilo.

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

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

=> (lista* 1)
1

=> (contro? (lista* 1 2 3 4))
I veri

macroespandere
Novità nella versione 0.10.0.

Uso: (macroespandi modulo)

Restituisce l'intera espansione macro di modulo.

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

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

macroespandi-1
Novità nella versione 0.10.0.

Uso: (macroespandi-1 modulo)

Restituisce l'espansione macro a passo singolo di modulo.

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

fondersi con
Novità nella versione 0.10.1.

Uso: (unione-con f &riposo mappe)

Restituisce una mappa che consiste del resto delle mappe unite per prime. Se una chiave si verifica in
più di una mappa, le mappature di quest'ultima (da sinistra a destra) saranno combinate con
la mappatura nel risultato chiamando (f val-in-risultato val-in-ultimo).

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

negativo?
Uso: (negativo? x)

Reso I veri if x è minore di zero. aumenta Digitare Errore if Non sei (numerico? X)).

=> (negativo? -2)
I veri

=> (negativo? 3)
Falso

=> (negativo? 0)
Falso

zero?
Uso: (zero? x)

Reso I veri if x is zero / Nessuna.

=> (zero? zero)
I veri

=> (zero? Nessuno)
I veri

=> (zero? 0)
Falso

=> (setf x zero)
=> (zero? x)
I veri

=> ;; list.append restituisce sempre Nessuno
=> (zero? (.append [1 2 3] 4))
I veri

nessuno?
Uso: (nessuno? x)

Reso I veri if x is Nessuna.

=> (nessuno? Nessuno)
I veri

=> (nessuno? 0)
Falso

=> (setf x Nessuno)
=> (nessuno? x)
I veri

=> ;; list.append restituisce sempre Nessuno
=> (nessuno? (.append [1 2 3] 4))
I veri

ennesimo
Uso: (ennesimo Coll n &opzionale [predefinito zero])

Restituisce il n-esimo elemento in una raccolta, contando da 0. Restituisce il valore predefinito, zero, Se
fuori limite (se non diversamente specificato). aumenta ValoreErrore if n è negativo.

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

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

=> (zero? (ennesimo [1 2 4 7] 5))
I veri

=> (ennesimo [1 2 4 7] 5 "predefinito")
'Default'

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

=> (ennesimo [1 2 4 7] -1)
Traceback (ultima chiamata più recente):
...
ValueError: gli indici per islice() devono essere None o un numero intero: 0 <= x <= sys.maxsize.

numerico?
Uso: (numerico? x)

Reso I veri if x è un numerico, come definito in Python's numeri.Numero classe.

=> (numerico? -2)
I veri

=> (numerico? 3.2)
I veri

=> (numerico? "pippo")
Falso

strano?
Uso: (strano? x)

Reso I veri if x è strano. aumenta Digitare Errore if Non sei (numerico? X)).

=> (strano? 13)
I veri

=> (strano? 2)
Falso

=> (strano? 0)
Falso

posizione?
Uso: (pos? x)

Reso I veri if x è maggiore di zero. aumenta Digitare Errore if Non sei (numerico? X)).

=> (pos? 3)
I veri

=> (pos? -2)
Falso

=> (pos? 0)
Falso

secondo
Uso: (secondo colle)

Restituisce il secondo membro di Coll. Equivalente a (ottenere Coll 1).

=> (secondo [0 1 2])
1

alcuni
Novità nella versione 0.10.0.

Uso: (alcuni pred colle)

Restituisce il primo valore logicamente vero di (precedentemente x) per qualsiasi x in Coll, Altrimenti zero.
Reso zero if Coll è vuoto.

=> (alcuni anche? [2 4 6])
I veri

=> (zero? (qualcuno addirittura? [1 3 5]))
I veri

=> (zero? (qualche identità [0 "" []]))
I veri

=> (qualche identità [0 "stringa non vuota" []])
'stringa non vuota'

=> (zero? (qualcuno addirittura? []))
I veri

corda?
Uso: (corda? x)

Reso I veri if x è una stringa.

=> (stringa? "pippo")
I veri

=> (stringa? -2)
Falso

simbolo?
Uso: (simbolo? x)

Reso I veri if x è un simbolo.

=> (simbolo? 'pippo)
I veri

=> (simbolo? '[abc])
Falso

zero?
Uso: (zero? x)

Reso I veri if x è zero.

=> (zero? 3)
Falso

=> (zero? -2)
Falso

=> (zero? 0)
I veri

Sequenza funzioni
Le funzioni di sequenza possono creare o operare su una sequenza potenzialmente infinita senza
richiedendo che la sequenza sia completamente realizzata in un elenco o in un contenitore simile. Lo fanno da
restituendo un iteratore Python.

Possiamo usare il generatore di numeri di Fibonacci infinito canonico come esempio di come usare
alcune di queste funzioni.

(definire fib []
(impostare a 0)
(set b 1)
(mentre vero
(produrre a)
(setv (, ab) (, b (+ ab)))))

Notare la (mentre vero ...) ciclo continuo. Se eseguiamo questo nel REPL,

=> (fib)


La chiamata alla funzione restituisce solo un iteratore, ma non funziona finché non lo consumiamo.
Non è consigliabile provare qualcosa del genere poiché il ciclo infinito verrà eseguito fino a quando non lo farà
consuma tutta la RAM disponibile, o in questo caso fino a quando non l'ho ucciso.

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

Per ottenere i primi 10 numeri di Fibonacci, usa prendere. Nota che prendere restituisce anche un generatore,
quindi creo un elenco da esso.

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

Per ottenere il numero di Fibonacci all'indice 9, (a partire da 0):

=> (ennesimo (fib) 9)
34

ciclo
Uso: (ciclo colle)

Restituisce un iteratore infinito dei membri di coll.

=> (lista (prendi 7 (ciclo [1 2 3])))
[1, 2, 3, 1, 2, 3, 1]

=> (lista (prendi 2 (ciclo [1 2 3])))
[1, 2]

distinto
Uso: (distinta colle)

Restituisce un iteratore contenente solo i membri univoci in Coll.

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

=> (lista (distinto []))
[]

=> (lista (distinta (iter [ 1 2 3 4 3 5 2 ])))
[1, 2, 3, 4, 5]

cadere
Uso: (far cadere n colle)

Restituisce un iteratore, saltando il primo n membri Coll. aumenta ValoreErrore if n is
negativo.

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

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

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

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

ultima goccia
Uso: (goccia-ultimo n colle)

Restituisce un iteratore di tutti tranne l'ultimo n articoli in Coll. aumenta ValoreErrore if n is
negativo.

=> (elenco (drop-ultimi 5 (intervallo 10 20)))
[10, 11, 12, 13, 14]

=> (elenco (drop-ultimo 0 (intervallo 5)))
[0, 1, 2, 3, 4]

=> (elenco (drop-ultimo 100 (intervallo 100)))
[]

=> (importa itertools)
=> (list (take 5 (drop-last 100 (itertools.count 10))))
[10, 11, 12, 13, 14]

goccia-mentre
Uso: (goccia-mentre pred colle)

Restituisce un iteratore, saltando i membri di Coll fino a quando pred is Falso.

=> (elenco (drop-mentre pari? [2 4 7 8 9]))
[7, 8, 9]

=> (elenco (drop-while numerico? [1 2 3 Nessuno "a"])))
[Nessuno, tu]

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

filtro
Uso: (filtro pred colle)

Restituisce un iteratore per tutti gli elementi in Coll che passano il predicato pred.

Vedi anche rimuovere.

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

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

appiattire
Novità nella versione 0.9.12.

Uso: (appiattire colle)

Restituisce un unico elenco di tutti gli elementi in Coll, appiattendo tutte le liste contenute e/o
tuple.

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

=> (appiattisci ["pippo" (, 1 2) [1 [2 3] 4] "barra"])
['pippo', 1, 2, 1, 2, 3, 4, 'bar']

iterate
Uso: (iterare fn x)

Restituisce un iteratore di x, fn(x), fn(fn(x)), ecc.

=> (lista (prendi 5 (iterate inc 5)))
[5, 6, 7, 8, 9]

=> (elenco (prendi 5 (itera (fn [x] (* xx)) 5)))
[5, 25, 625, 390625, 152587890625]

read
Uso: (leggere &opzionale [dal file eof])

Legge la prossima espressione Hy da dal file (predefinito su sys.stdin), e può prendere a
singolo byte come EOF (il valore predefinito è una stringa vuota). aumenta EOFErrore if dal file finisce prima
un'espressione completa può essere analizzata.

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

=> (importa io)
=> (def buffer (io.StringIO "(+ 2 2)\n(- 2 1)"))
=> (eval (applica read [] {buffer "from_file"}))
4
=> (eval (applica read [] {buffer "from_file"}))
1

=> ; supponendo che "example.hy" contenga:
=> ; (stampa "ciao")
=> ; (stampa "amici!")
=> (con [[f (apri "esempio.hy")]]
... (Tentativo
... (mentre vero
... (let [[exp (leggi f)]]
... (fare
... (stampa "OHY" esp)
... (exp eval))))
... (cattura [e EOFError]
... (stampa "EOF!"))))
OHY ('stampa' 'ciao')
Ciao
OHY ("stampa" "amici!")
amici!
EOF!

rimuovere
Uso: (rimuovere pred colle)

Restituisce un iteratore da Coll con elementi che passano il predicato, pred, RIMOSSO.

Vedi anche filtro.

=> (lista (elimina dispari? [1 2 3 4 5 6 7]))
[2, 4, 6]

=> (lista (rimuovi pos? [1 2 3 4 5 6 7]))
[]

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

ripetere
Uso: (ripetere x)

Restituisce un iteratore (infinito) di x.

=> (lista (prendi 6 (ripeti "s")))
[sì, tu', tu', tu', tu', tu']

ripetutamente
Uso: (ripetutamente fn)

Restituisce un iteratore chiamando fn ripetutamente.

=> (importazione [random [randint]])

=> (lista (prendi 5 (ripetutamente (fn [] (randint 0 10)))))
[6, 2, 0, 6, 7]

prendere
Uso: (prendere n colle)

Restituisce un iteratore contenente il primo n membri Coll. aumenta ValoreErrore if n is
negativo.

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

=> (lista (prendi 4 (ripeti "s")))
[tu', voi', voi', voi']

=> (lista (prendi 0 (ripeti "s")))
[]

prendere-nth
Uso: (prendere-nth n colle)

Restituisce un iteratore contenente ogni n-esimo membro di Coll.

=> (lista (take-nth 2 [1 2 3 4 5 6 7]))
[1, 3, 5, 7]

=> (lista (take-nth 3 [1 2 3 4 5 6 7]))
[1, 4, 7]

=> (lista (take-nth 4 [1 2 3 4 5 6 7]))
[1, 5]

=> (lista (take-nth 10 [1 2 3 4 5 6 7]))
,

prendi mentre
Uso: (prendere intanto) pred colle)

Restituisce un iteratore da Coll fintanto che pred problemi I veri.

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

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

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

zipcon
Novità nella versione 0.9.13.

Uso: (zip fn Coll ...)

Equivalente a chiusura, ma usa una funzione multi-argomento invece di creare una tupla. Se
zipcon viene chiamato con N raccolte, quindi fn deve accettare N argomenti.

=> (operatore di importazione)
=> (lista (zipcon operatore.add [1 2 3] [4 5 6]))
[5, 7, 9]

Lettore Macro
Le macro del lettore danno a Lisp il potere di modificare e alterare la sintassi al volo. non vuoi
Notazione polacca? Una macro del lettore può facilmente fare proprio questo. Vuoi il modo di Clojure di avere un
regex? Anche le macro del lettore possono farlo facilmente.

Sintassi
=> (defreader ^ [espr] (stampa espr))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Ciao"
"Ciao"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

Hy non ha letterali per le tuple. Diciamo che non ti piace (, ...) e vuoi qualcos'altro. Questo
è un problema che le macro del lettore sono in grado di risolvere in modo ordinato.

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

Potresti anche farlo come Clojure e avere un letterale per le espressioni regolari!

=> (importa re)
=> (defreader r [espr] `(ri.compila ~espr))
=> #r".*"
<_sre.SRE_Pattern oggetto su 0xcv7713ph15#>

Implementazione
deflettore prende un singolo carattere come nome del simbolo per la macro del lettore; niente di più
restituirà un errore. A livello di implementazione, deflettore si espande in una lambda ricoperta di a
decoratore. Questo decoratore salva la lambda in un dizionario con il nome del modulo e
simbolo.

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

# si espande in (macro_lettore_invio ...) dove viene passato il simbolo e l'espressione a
la funzione corretta.

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

ATTENZIONE:
A causa di una limitazione nel lexer e nel parser di Hy, le macro del lettore non possono ridefinire definite
sintassi come ()[]{}. Questo sarà molto probabilmente affrontato in futuro.

Interno Hy Documentazione
NOTA:
Questi bit sono principalmente utili per le persone che hackerano lo stesso Hy, ma possono anche essere usati per
coloro che approfondiscono la programmazione macro.

Hy Modelli
Introduzione a Hy Modelli
I modelli Hy sono uno strato molto sottile sopra i normali oggetti Python, che rappresentano la sorgente Hy
codice come dati. I modelli aggiungono solo informazioni sulla posizione della sorgente e una manciata di metodi per
supportano la manipolazione pulita del codice sorgente Hy, ad esempio nelle macro. Per raggiungere questo obiettivo
obiettivo, i modelli Hy sono mixin di una classe Python di base e HyOggetto.

HyOggetto
hy.models.HyObject è la classe base dei modelli Hy. Implementa solo un metodo, sostituire,
che sostituisce la posizione sorgente dell'oggetto corrente con quella passata come argomento.
Questo ci permette di tenere traccia della posizione originale delle espressioni che vengono modificate da
macro, sia nel compilatore che nelle macro hy pure.

HyOggetto non è pensato per essere utilizzato direttamente per istanziare modelli Hy, ma solo come mixin
per altre classi.

Compound Modelli
Gli elenchi tra parentesi e tra parentesi vengono analizzati come modelli composti dal parser Hy.

HyList
hy.models.list.HyList è la classe base dei modelli Hy "iterabili". Il suo uso di base è quello di
rappresentare tra parentesi [] liste, che, se usate come espressione di primo livello, si traducono in
Letterali dell'elenco Python in fase di compilazione.

L'aggiunta di un HyList a un altro oggetto iterabile riutilizza la classe dell'oggetto di sinistra,
un comportamento utile quando si desidera concatenare oggetti Hy in una macro, ad esempio.

HyExpression
hy.models.expression.HyExpression eredita HyList per parentesi () espressioni. Il
il risultato della compilazione di tali espressioni dipende dal primo elemento della lista: the
il compilatore invia le espressioni tra i moduli speciali del compilatore, le macro definite dall'utente e
normali chiamate di funzione Python.

HyDict
hy.models.dict.HyDict eredita HyList per parentesi graffe {} espressioni, che compilano
fino a un letterale dizionario Python.

La decisione di usare una lista invece di un dict come classe base per HyDict permette più facile
manipolazione dei dict nelle macro, con l'ulteriore vantaggio di consentire espressioni composte
come dict key (come, ad esempio, il HyExpression La classe Python non è hashable).

Atomico Modelli
Nel flusso di input, stringhe tra virgolette, rispettando la notazione Python per le stringhe,
vengono analizzati come un singolo token, che viene analizzato direttamente come a HyString.

Una stringa ininterrotta di caratteri, esclusi spazi, parentesi quadre, virgolette, virgolette
e commenti, viene analizzato come identificatore.

Gli identificatori vengono risolti in modelli atomici durante la fase di analisi nel seguente ordine:

· HyIntero

· HyFloat

· Complesso Hy (se l'atomo non è nudo j)

· HyParola chiave (se l'atomo inizia con :)

· HySimbolo

HyString
hy.models.string.HyString è la classe base dei modelli Hy equivalenti alle stringhe. anche
rappresenta letterali stringa tra virgolette, "", che compilano in una stringa unicode
letterali in Python. HyStrings eredita oggetti unicode in Python 2 e oggetti stringa in
Python 3 (e quindi non dipendono dalla codifica).

HyString i modelli basati sono immutabili.

Le stringhe letterali Hy possono estendersi su più righe e sono considerate dal parser come singole
unit, rispettando gli escape Python per le stringhe unicode.

Numerico Modelli
hy.models.integer.HyInteger rappresenta letterali interi (usando il lungo digita su Python 2,
ed int su Python 3).

hy.models.float.HyFloat rappresenta letterali in virgola mobile.

hy.models.complex.HyComplex rappresenta letterali complessi.

I modelli numerici vengono analizzati utilizzando la corrispondente routine Python e python numerico valido
i letterali verranno trasformati nella loro controparte Hy.

HySimbolo
hy.models.symbol.HySymbol è il modello utilizzato per rappresentare i simboli nel linguaggio Hy. Esso
eredita HyString.

HySimbolo gli oggetti vengono alterati nella fase di analisi, per aiutare l'interoperabilità di Python:

· Simboli circondati da asterischi (*) sono convertiti in maiuscolo;

· trattini (-) vengono trasformati in trattini bassi (_);

· Un punto interrogativo finale (?) è trasformato in un leader è_.

Avvertenza: poiché la storpiatura viene eseguita durante la fase di analisi, è possibile
generare a livello di codice HySymbols che non possono essere generati con il codice sorgente Hy. Come un
meccanismo è utilizzato da gensym per generare simboli "non interni".

HyParola chiave
hy.models.keyword.HyKeyword rappresenta le parole chiave in Hy. Le parole chiave sono simboli che iniziano con
a :. La classe eredita HyString.

Distinguere HyParole Chiave da HySimboli, senza possibilità di (involontario)
clash, il carattere unicode per uso privato "\uFDD0" è anteposto alla parola chiave letterale
prima dello stoccaggio.

Svantaggi Celle
hy.models.cons.HyCons è una rappresentazione di Python-friendly cons cellule. Contro le cellule sono
particolarmente utile per imitare le caratteristiche delle "solite" varianti LISP come Scheme o Common
Liscio

Una cella cons è un oggetto a 2 elementi, contenente a auto (testa) e a cdr (coda). In alcuni Lisp
varianti, la cella contro è l'elemento costitutivo fondamentale e le espressioni S sono in realtà
rappresentati come elenchi collegati di celle contro. Questo non è il caso di Hy, come al solito
le espressioni sono fatte di elenchi Python racchiusi in a HyExpression. Tuttavia, l' HyCons
imita così il comportamento delle "solite" varianti Lisp:

· (contro qualcosa zero) is (HyEspressione [qualcosa])

· (contro qualcosa qualche elenco) is ((genere qualche elenco) (+ [qualcosa] qualche lista)) (Se
qualche-lista eredita da stratagemma).

· (ottenere (contro a b) 0) is a

· (fetta (contro a b) 1) is b

Hy supporta una sintassi di elenco punteggiato, dove '(un . b) si intende (contro 'a 'B) ed '(un b . c) si intende
(contro 'a (contro 'b 'C)). Se il compilatore incontra una cella contro al livello più alto, solleva
un errore di compilazione.

HyCons avvolge gli argomenti passati (car e cdr) nei tipi Hy, per facilitare la manipolazione di
contro le celle in un contesto macro.

Hy Interno Teoria
Panoramica
Gli interni di Hy funzionano fungendo da front-end per il bytecode Python, in modo che Hy stesso
compila in Python Bytecode, consentendo a un runtime Python non modificato di eseguire il codice Hy,
senza nemmeno accorgersene.

Il modo in cui lo facciamo è tradurre Hy in una struttura dati AST Python interna e
costruire quell'AST nel bytecode Python usando i moduli dallo standard Python
libreria, in modo da non dover duplicare tutto il lavoro degli interni di Python per ogni
singola versione di Python.

Hy lavora in quattro fasi. Le sezioni seguenti copriranno ogni passaggio di Hy dalla sorgente a
tempo di esecuzione.

Passi 1 ed 2: creazione di token ed parsing
La prima fase della compilazione di Hy consiste nel lex della sorgente in token con cui possiamo occuparci. Noi
usa un progetto chiamato rply, che è un parser davvero carino (e veloce), scritto in un sottoinsieme
di Python chiamato rpython.

Il codice lexing è tutto definito in hy.lex.lexer. Questo codice è per lo più solo definendo l'Hy
grammatica, e tutte le parti difficili effettive sono curate da rply -- definiamo solo
"richiamate" per rply in hy.lex.parser, che prende i token generati e restituisce il
Hy modelli.

Puoi pensare ai modelli Hy come "AST" per Hy, è ciò su cui operano i Macro
(direttamente), ed è ciò che il compilatore usa quando compila Hy verso il basso.

VEDERE INOLTRE:
Sezione Hy Modelli per maggiori informazioni sui modelli Hy e sul loro significato.

step 3: Hy compilazione a Python AST
È qui che avviene la maggior parte della magia in Hy. Qui è dove prendiamo Hy AST (i modelli),
e compilarli in Python AST. Un paio di cose stravaganti accadono qui per funzionare dopo alcune
problemi in AST e lavorare nel compilatore è uno dei lavori più importanti che facciamo
avere.

Il compilatore è un po' complesso, quindi non sentirti in colpa se non lo crei al primo colpo,
potrebbe volerci un po' di tempo per ottenere il giusto.

Il principale punto di accesso al compilatore è HyASTCompiler.compile. Questo metodo viene invocato e
l'unico vero metodo "pubblico" sulla classe (vale a dire, non promettiamo davvero il
API oltre quel metodo).

Infatti, anche internamente, non ricorriamo direttamente quasi mai, quasi sempre forziamo
l'albero di Hy attraverso compilare, e lo farà spesso con i sottoelementi di un'espressione
che noi abbiamo. Spetta al dispatcher basato sul tipo inviare correttamente i sottoelementi.

Tutti i metodi che preformano una compilazione sono contrassegnati con il @costruisce() decoratore. Puoi
passa la classe del modello Hy che compila, oppure puoi usare una stringa per
espressioni. Lo chiarirò in un secondo.

Nome Stage Tipo-Spedizione
Iniziamo nel compilare metodo. La prima cosa che facciamo è controllare il tipo della cosa
stiamo costruendo. Alziamo lo sguardo per vedere se abbiamo un metodo in grado di costruire il genere() che noi
avere e inviare al metodo che può gestirlo. Se non abbiamo metodi in grado di farlo
costruiamo quel tipo, alziamo un interno Eccezione.

Ad esempio, se abbiamo a HyString, abbiamo una mappatura quasi 1 a 1 di Hy AST in Python
AST. Il stringa_compilazione il metodo prende il HyString, e restituisce an st.Str()
popolato con i numeri di riga e il contenuto corretti.

Macro-espandi
Se otteniamo un HyExpression, proveremo a vedere se questa è una Macro nota e spingeremo per avere
si espanse invocando hy.macro.macroexpand, quindi reinserisci il risultato in
HyASTCompiler.compile.

Secondo Stage Espressione-Dispatch
L'unico caso speciale è il HyExpression, poiché dobbiamo creare diversi AST a seconda
sull'apposito modulo in oggetto. Ad esempio, quando colpiamo un (Se vero vero false), noi
bisogno di generare a ast.See compilare correttamente i sottonodi. Questo è dove il @costruisce()
con una stringa come argomento entra.

Per la espressione_compilazione (che è definito con an @builds(HyExpression)) spedirà
in base alla stringa del primo argomento. Se, per qualche ragione, il primo argomento non lo è
una stringa, gestirà correttamente anche quel caso (molto probabilmente sollevando an Eccezione).

Se la stringa non è nota a Hy, creerà per impostazione predefinita un ast.Chiama, che cercherà di
fai una chiamata di runtime (in Python, qualcosa del tipo pippo()).

Problema Colpire con Python AST
Python AST è fantastico; è ciò che ci ha permesso di scrivere un progetto così potente sopra
Python senza dover combattere troppo duramente contro Python. Come ogni cosa, abbiamo avuto la nostra giusta dose di
problemi, ed ecco un breve elenco di quelli comuni in cui potresti imbatterti.

Python differenzia fra Report ed Espressioni.

Questo potrebbe non sembrare un grosso problema, in effetti, per la maggior parte dei programmatori Python, questo lo farà
presto diventare un momento "Beh, sì".

In Python, facendo qualcosa del tipo:

stampare per x in gamma(10) passare, perché stampare stampa espressioni, e per non è un
espressione, è un'istruzione di flusso di controllo. Cose come 1 + 1 sono espressioni, così come sono lambda
x: 1 + x, ma altre caratteristiche del linguaggio, come if, per, o while sono dichiarazioni.

Dal momento che non hanno alcun "valore" per Python, questo rende difficile lavorare in Hy, dal momento che fare qualcosa
piace (Stampa (Se vero vero falso)) non è solo comune, è previsto.

Di conseguenza, modifichiamo automaticamente le cose usando a Risultato oggetto, dove offriamo qualsiasi ast.stmt
che hanno bisogno di correre, e un singolo espr.ast che può essere usato per ottenere il valore di qualunque cosa
è stato appena eseguito. Hy lo fa forzando l'assegnazione delle cose durante l'esecuzione.

Ad esempio, l'Hy:

(stampa (se vero vero falso))

si trasformerà in:

se è vero:
_manngled_name_here = Vero
altro:
_manngled_name_here = Falso

stampa _nome_distorto_qui

OK, era un po' una bugia, dal momento che in realtà trasformiamo quell'affermazione in:

print Vero se Vero altrimenti Falso

Forzando le cose in an espr.ast se possiamo, ma l'idea generale vale.

step 4: Python codice a byte Uscita ed Runtime
Dopo che abbiamo un albero AST Python completo, possiamo provare a compilarlo in Python
bytecode spingendolo attraverso eval. Da qui in poi, non abbiamo più il controllo e
Python si sta occupando di tutto. Questo è il motivo per cui cose come i traceback Python, pdb e
le app django funzionano

Hy Macro
utilizzando gensim per Safer Macro
Quando si scrivono macro, bisogna stare attenti a evitare di catturare variabili esterne o usare
nomi di variabili che potrebbero entrare in conflitto con il codice utente.

Useremo una macro di esempio nif (Vedi
http://letoverlambda.com/index.cl/guest/chap3.html#sec_5 per una descrizione più completa.)
nif è un esempio, qualcosa come un numerico if, dove in base all'espressione, uno dei
3 forme vengono chiamate a seconda che l'espressione sia positiva, zero o negativa.

Un primo passaggio potrebbe essere qualcosa del tipo:

(defmacro nif [espr pos-form forma zero forma neg]
`(let [[nome-oscuro ~espr]]
(cond [(pos? nome-oscuro) ~forma-pos]
[(zero? nome-oscuro) ~forma-zero]
[(negativo? nome-oscuro) ~forma-negativa])))

where nome-oscura è un tentativo di scegliere il nome di una variabile per non entrare in conflitto con altre
codice. Ma ovviamente, anche se ben intenzionato, questa non è una garanzia.

Il metodo gensym è progettato per generare un simbolo nuovo e unico proprio per un'occasione del genere.
Una versione molto migliore di nif sarebbe:

(defmacro nif [espr pos-form forma zero forma neg]
(lascia [[g (gensym)]]
`(lascia [[~g ~espr]]
(cond [(pos? ~g) ~pos-forma]
[(zero? ~g) ~forma zero]
[(negativo? ~g) ~forma-negativa]))))

Questo è un caso facile, poiché c'è un solo simbolo. Ma se ce n'è bisogno di diversi
gensym's c'è una seconda macro with-gensyms che sostanzialmente si espande in una serie di lasciare
dichiarazioni:

(con-gensyms [abc]
...)

si espande a:

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

quindi il nostro riscritto nif sembrerebbe:

(defmacro nif [espr pos-form forma zero forma neg]
(con-gensyms [g]
`(lascia [[~g ~espr]]
(cond [(pos? ~g) ~pos-forma]
[(zero? ~g) ~forma zero]
[(negativo? ~g) ~forma-negativa]))))

Finalmente, però, possiamo creare una nuova macro che faccia tutto questo per noi. defmacro/g! ci vorrà
tutti i simboli che iniziano con g! e chiama automaticamente gensim con il resto del
simbolo. Così g! a potrebbe diventare (gensim "un").

La nostra versione finale di nif, costruito con defmacro/g! diventa:

(defmacro/g! nif [espr pos-form forma zero forma neg]
`(lascia [[~g!res ~espr]]
(cond [(pos? ~g!res) ~pos-forma]
[(zero? ~g!res) ~forma zero]
[(neg? ~g!res) ~forma-neg]))))

Controllo Macro argomenti ed Raccolta Eccezioni
Hy Compiler Built-Ins

COLLABORATORE MODULI INDICE

Contenuto:

anaforico Macro
Novità nella versione 0.9.12.

Il modulo macro anaforico rende la programmazione funzionale in Hy molto concisa e facile da
leggere.
Una macro anaforica è un tipo di macro di programmazione che cattura deliberatamente una forma
fornito alla macro che può essere indicata da un'anafora (un'espressione che fa riferimento a
ad un altro). — Wikipedia (http://en.wikipedia.org/wiki/Anaphoric_macro)

Macro
ap-se
Uso: (ap-se (pippo) (Stampa esso))

Valuta la prima forma per veridicità e legarla a it sia nel vero che nel falso
rami.

una pesca
Uso: (una pesca [1 2 3 4 5] (Stampa esso))

Valuta il modulo per ogni elemento nell'elenco per gli effetti collaterali.

ogni tanto
Uso: (ap-ogni-mentre stratagemma pred corpo)

Valuta il modulo per ogni elemento in cui restituisce il modulo del predicato I veri.

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

ap-mappa
Uso: (ap-mappa modulo elenco)

La forma anaforica della mappa funziona proprio come una mappa normale tranne che al posto di una funzione
oggetto assume una forma Hy. Il nome speciale it è legato all'oggetto corrente dal
elenco nell'iterazione.

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

ap-map-quando
Uso: (ap-map-quando prefn rep elenco)

Valutare una mappatura sull'elenco utilizzando una funzione di predicato per determinare quando applicare il
forma.

=> (list (ap-map-quando dispari? (* it 2) [1 2 3 4]))
[2, 2, 6, 4]

=> (list (ap-map-quando pari? (* it 2) [1 2 3 4]))
[1, 4, 3, 8]

ap-filtro
Uso: (ap-filtro modulo elenco)

Come con ap-mappa prendiamo una forma speciale invece di una funzione per filtrare gli elementi del
elenco. Il nome speciale it è legato all'elemento corrente nell'iterazione.

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

ap-rifiuto
Uso: (ap-rifiuto modulo elenco)

Questa funzione fa l'opposto di ap-filtro, rifiuta gli elementi che passano il
predicato. Il nome speciale it è legato all'elemento corrente nell'iterazione.

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

ap-dotimes
Impiego (ap-dotimes n corpo)

Questa funzione valuta il corpo n volte, con la variabile speciale it legato da 0 a
1-n. È utile per gli effetti collaterali.

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

ap-primo
Impiego (ap-prima prefn elenco)

Questa funzione restituisce il primo elemento che passa il predicato o Nessuna, Con l'
variabile speciale it legato all'elemento corrente nell'iterazione.

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

ap-ultimo
Impiego (ap-ultimo prefn elenco)

Questa funzione restituisce l'ultimo elemento che passa il predicato o Nessuna, con lo speciale
variabile it legato all'elemento corrente nell'iterazione.

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

ap-ridurre
Impiego (ap-ridurre modulo stratagemma &opzionale valore iniziale)

Questa funzione restituisce il risultato dell'applicazione della forma ai primi 2 elementi nel corpo e
applicando il risultato e il 3° elemento ecc. fino ad esaurimento della lista. Facoltativamente e
il valore iniziale può essere fornito in modo che la funzione venga applicata al valore iniziale e il
primo elemento invece. Questo espone l'elemento che viene iterato come it e la corrente
valore accumulato come acc.

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

loop/ricorre
Novità nella versione 0.10.0.

I loop / ripresentarsi macro offre ai programmatori un modo semplice per utilizzare l'ottimizzazione tail-call (TCO)
nel loro codice Hy.
Una chiamata di coda è una chiamata di subroutine che avviene all'interno di un'altra procedura come sua finale
azione; può produrre un valore di ritorno che viene poi immediatamente restituito dal chiamante
procedura. Se una qualsiasi chiamata esegue una subroutine, in modo tale che potrebbe eventualmente portare
a questa stessa subroutine essendo chiamata di nuovo lungo la catena di chiamata, è in posizione di coda,
tale subroutine è detta ricorsiva in coda, che è un caso speciale di ricorsione.
Le chiamate di coda sono significative perché possono essere implementate senza aggiungere un nuovo stack
frame allo stack di chiamate. La maggior parte del frame della procedura attuale non è necessaria alcuna
more, e può essere sostituito dal frame della chiamata di coda. Il programma può quindi saltare
al sottoprogramma chiamato. La produzione di tale codice invece di una sequenza di chiamate standard è
chiamata eliminazione della chiamata in coda o ottimizzazione della chiamata in coda. L'eliminazione della chiamata in coda consente
le chiamate di procedura in coda devono essere implementate con la stessa efficienza delle istruzioni goto,
consentendo così una programmazione strutturata efficiente. — Wikipedia (‐
http://en.wikipedia.org/wiki/Tail_call)

Macro
loop
loop stabilisce un punto di ricorsione. Con loop, ripresentarsi riassocia le variabili impostate in
punto di ricorsione e rimanda l'esecuzione del codice a quel punto di ricorsione. Se ripresentarsi è usato in
una posizione non di coda, viene generata un'eccezione.

Uso: (ciclo continuo attacchi &riposo corpo)

Esempio:

(richiede hy.contrib.loop)

(def. fattoriale [n]
(ciclo [[in] [acc 1]]
(se (zero? io)
acc
(ricorre (dec i) (* acc i))))))

(fattoriale 1000)

defmulti
Novità nella versione 0.10.0.

defmulti ti permette di sovraccaricare una funzione con un dato numero di args e/o kwarg.
Ispirato alla versione di Clojure def.

=> (richiedi hy.contrib.multi)
=> (defmulti divertimento
... ([aa")
... ([ab] "ab")
... ([abc] "abc"))
=> (divertimento 1)
"un"
=> (divertimento 1 2)
"ab"
=> (divertimento 1 2 3)
"abc"

HACKING ON HY

Registrati nostro Hyve!
Per favore, vieni a hackerare Hy!

Per favore, vieni a stare con noi su #ciao on irc.freenode.net!

Per favore, parlane su Twitter con il #ciao hashtag!

Si prega di blog su di esso!

Per favore, non spruzzarlo sulla recinzione del tuo vicino (senza chiedere gentilmente)!

Hack!
Fai questo:

1. Creare un virtuale ambiente:

$ virtualenv venv

e attivalo:

$. venv/bin/activate

o usare virtualenvwrapper per creare e gestire il tuo ambiente virtuale:

$ mkvirtualenv hy
$ lavoro su hy

2. Ottieni il codice sorgente:

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

oppure usa la forchetta:

Clone $ git [email protected]: /hy.git

3. Installa per l'hacking:

$ cd hy/
$ pip installa -e .

4. Installa altri requisiti di sviluppo:

$ pip install -r requisiti-dev.txt

5. Fai cose fantastiche; fai urlare qualcuno di gioia/disgusto per ciò che hai combinato.

Test!
I test si trovano in test /. Noi usiamo naso.

Per eseguire i test:

$ test del naso

Scrivi test --- i test sono buoni!

Inoltre, è bene eseguire i test per tutte le piattaforme supportate e conformi a PEP 8
codice. Puoi farlo eseguendo tox:

$tox

Documento!
La documentazione si trova in documenti /. Noi usiamo Sfinge.

Per creare i documenti in HTML:

$ cd documenti
$ crea html

Scrivi documenti --- i documenti sono buoni! Anche questo dottore!

Contribuire
I contributi sono benvenuti e molto apprezzati, ogni piccola parte aiuta a rendere Hy di più
eccezionale.

Le richieste di pull sono fantastiche! Li amiamo; ecco una rapida guida:

· Eseguire il fork del repository e creare un ramo di argomento per una funzionalità/correzione. Evita di apportare modifiche direttamente
sul ramo principale.

· Tutte le funzionalità in entrata devono essere accompagnate da test.

· Prima di inviare un PR, eseguire i test e verificare il codice rispetto allo stile
guida. Puoi fare entrambe queste cose contemporaneamente:

$ fare d

· Trasforma i commit in unità logiche, in modo che sia più facile tracciare e navigare in un secondo momento. Prima
inviando un PR, prova a schiacciare i commit in set di modifiche a cui è facile tornare
dopo. Inoltre, assicurati di non lasciare spazi vuoti spuri nei set di modifiche; questo
evita la creazione di commit di correzione degli spazi vuoti in seguito.

· Per quanto riguarda i messaggi di commit, prova a rispettare quanto segue:

· Prova a rispettare il limite di 50 caratteri per la prima riga dei messaggi di commit Git.

· Per maggiori dettagli/spiegazioni, prosegui con una riga vuota e continua
descrivendo in dettaglio il commit.

· Infine, aggiungi te stesso al file AUTHORS (come commit separato): te lo meriti :)

· Tutte le modifiche in arrivo devono essere approvate da 2 diversi membri del team principale di Hylang.
Un'ulteriore revisione è chiaramente benvenuta, ma abbiamo bisogno di un minimo di 2 approvazioni per ognuna
cambiare.

· Se un membro principale sta inviando una PR, trova 2 membri principali che non includono il
Presentatore di pubbliche relazioni. L'idea qui è che si può lavorare con l'autore PR e un secondo acks
l'intero set di modifiche.

· Per la documentazione e altre modifiche banali, è bene unire dopo un ACK. Abbiamo
bassa copertura, quindi sarebbe fantastico mantenere bassa quella barriera.

Nucleo Team
Il team di sviluppo principale di Hy è composto dai seguenti sviluppatori:

· giuliano Danjou

· Morten Linderud

· J Kenneth King

· Gergely Nagy

· Tuuka Turto

· Karen ruggine

· Abhishek L

· Christopher Allan Webber

· Konrad Hinsen

· Will Kahn Greene

· Paul Tagliamonte

· Nicolas Dandrimont

· Bob Tolbert

· Berker Peksag

· Clinton N. Dreisbach

· lui semagg

Usalo online usando i servizi onworks.net