hy - Online en la nube

PROGRAMA:

NOMBRE

Hy-hy Documentation [imagen: Hy] [imagen]

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

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

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

Lista hylang-discutir

IRC #por que en Freenode

Construcción estado
Travis CI.SIN SANGRÍA

Hy es un maravilloso dialecto de Lisp que está incrustado en Python.

Dado que Hy transforma su código Lisp en el árbol de sintaxis abstracta de Python, ha
todo el hermoso mundo de Python a tu alcance, ¡en forma Lisp!

Contenido:

INICIO RÁPIDO

[imagen: Cuddles de Karen Rustard] [imagen]

(¡Gracias a Karen Rustad por Cuddles!)

COMO LAS A HY REAL RÁPIDO:

1. Crear un Virtual Python Entorno.

2. Active su entorno virtual de Python.

3. Instalar hy en PyPI pepita instalar hy.

4. Inicie un REPL con hy.

5. Escriba cosas en el REPL:

=> (imprimir "¡Hy!")
Hy!
=> (defn salutationsnm [nombre] (print (+ "Hy" nombre "!")))
=> (salutationsnm "YourName")
¡Hy YourName!

etc.

6. Presione CTRL-D cuando haya terminado.

OMG! Eso es ¡asombroso! I quieres a escribir a Hy .

7. Abra un editor de programación de élite y escriba:

(imprima "Iba a codificar en sintaxis Python, pero luego obtuve Hy").

8. Guardar como impresionante, por qué.

9. Y ejecute su primer programa Hy:

por qué impresionante.

10.
Respire profundamente para no hiperventilar.

11.
Sonríe malévolamente y escápate a tu hydeaway y haz cosas indescriptibles.

TUTORIAL

¡Bienvenido al tutorial de Hy!

En pocas palabras, Hy es un dialecto Lisp, pero uno que convierte su estructura en Python ...
¡literalmente una conversión en el árbol de sintaxis abstracta de Python! (O para ponerlo en más crudo
términos, Hy es lisp-stick en un Python!)

Esto es muy bueno porque significa que Hy es varias cosas:

· Un Lisp que se siente muy pitónico

· Para Lispers, una excelente manera de usar los locos poderes de Lisp pero en el amplio mundo de Python
bibliotecas (por qué sí, ¡ahora puede escribir una aplicación Django en Lisp!)

· Para los Pythonistas, ¡una excelente manera de comenzar a explorar Lisp, desde la comodidad de Python!

· Para todos: ¡un lenguaje agradable que tiene muchas ideas geniales!

Basic intro a Ceceo para pitonistas
De acuerdo, tal vez nunca hayas usado Lisp antes, ¡pero has usado Python!

Un programa de "hola mundo" en Hy es realmente muy simple. Vamos a intentarlo:

(imprime "hola mundo")

¿Ver? ¡Fácil! Como habrás adivinado, es lo mismo que la versión Python de:

imprimir "hola mundo"

Para sumar algunas matemáticas súper simples, podríamos hacer:

(+1)

Lo que devolvería 4 y sería el equivalente de:

1 + 3

Lo que notará es que el primer elemento de la lista es la función que se llama y el
el resto de los argumentos son los argumentos que se pasan. De hecho, en Hy (como con la mayoría
Lisps) podemos pasar múltiples argumentos al operador más:

(+1 3 55)

Que devolvería 59.

Quizás hayas oído hablar de Lisp antes, pero no sabes mucho sobre él. Lisp no es tan difícil como tú
podría pensar, y Hy hereda de Python, por lo que Hy es una excelente manera de comenzar a aprender Lisp.
Lo principal que es obvio sobre Lisp es que hay muchos paréntesis. Esto podría
parece confuso al principio, pero no es tan difícil. Veamos algunas matemáticas simples que son
envuelto en un montón de paréntesis que podríamos ingresar en el intérprete de Hy:

(resultado de setv (- (/ (+ 1 3 88) 2) 8))

Esto devolvería 38. ¿Pero por qué? Bueno, podríamos mirar la expresión equivalente en
pitón:

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

Si intentara averiguar cómo funcionaría lo anterior en Python, por supuesto
averigua los resultados resolviendo cada paréntesis interior. Esa es la misma idea básica en
Hy. Probemos este ejercicio primero en Python:

resultado = ((1 + 3 + 88) / 2) - 8
# simplificado a ...
resultado = (92/2) - 8
# simplificado a ...
resultado = 46 - 8
# simplificado a ...
resultado = 38

Ahora intentemos lo mismo en Hy:

(resultado de setv (- (/ (+ 1 3 88) 2) 8))
; simplificado a ...
(resultado de setv (- (/ 92 2) 8))
; simplificado a ...
(resultado de setv (- 46 8))
; simplificado a ...
(resultado de setv 38)

Como probablemente adivinaste, esta última expresión con setv significa asignar la variable
"resultado" a 38.

¿Ver? ¡No demasiado duro!

Esta es la premisa básica de Lisp. Lisp significa "procesamiento de listas"; esto significa que el
La estructura del programa es en realidad listas de listas. (Si está familiarizado con Python
listas, imagina toda la misma estructura que la anterior pero con corchetes en su lugar, cualquier
podrá ver la estructura anterior como un programa y una estructura de datos).
más fácil de entender con más ejemplos, así que vamos a escribir un programa Python simple, probarlo,
y luego mostrar el programa Hy equivalente:

def simple_conversation ():
print "¡Hola! Me gustaría conocerte. ¡Háblame de ti!"
name = raw_input ("¿Cómo te llamas?")
age = raw_input ("¿Cuál es su edad?")
imprimir "Hola" + nombre + "! Veo que tienes" + edad + "años".

conversación_simple ()

Si ejecutamos este programa, podría ser así:

¡Hola! Me gustaría conocerte. ¡Cuéntame sobre ti!
¿Cómo te llamas? Gary
¿Cuál es tu edad? 38
¡Hola Gary! Veo que tienes 38 años.

Ahora veamos el programa Hy equivalente:

(defn conversación simple []
(imprimir "¡Hola! Me gustaría conocerte. ¡Háblame de ti!")
(setv name (raw-input "¿Cuál es tu nombre?"))
(setv age (raw-input "¿Cuál es su edad?"))
(print (+ "Hola" nombre "! Veo que eres"
edad "años.")))

(conversación simple)

Si observa el programa anterior, siempre que recuerde que el primer elemento de cada
La lista del programa es la función (o macro ... veremos más adelante) que se llama
y que el resto son los argumentos, es bastante fácil averiguar qué significa todo esto.
(Como probablemente también adivinó, definir es el método Hy para definir métodos).

Aún así, mucha gente encuentra esto confuso al principio porque hay muchos paréntesis,
pero hay muchas cosas que pueden ayudar a que esto sea más fácil: mantenga la sangría agradable y
utilice un editor que coincida con paréntesis (esto le ayudará a averiguar qué
el paréntesis se empareja con) y las cosas comenzarán a sentirse cómodas.

Hay algunas ventajas de tener una estructura de código que en realidad es un dato muy simple
estructura en la que se basa el núcleo de Lisp. Por un lado, significa que sus programas son
fácil de analizar y que toda la estructura real del programa está expuesta con mucha claridad
para ti. (Hay un paso adicional en hy donde la estructura que ve se convierte en Python
propias representaciones ... en Lisps "más puros" como Common Lisp o Emacs Lisp, los datos
estructura que ves en el código y la estructura de datos que se ejecuta es mucho más
literalmente cerca.)

Otra implicación de esto son las macros: si la estructura de un programa es un dato simple
estructura, eso significa que puede escribir código que puede escribir código muy fácilmente, lo que significa que
implementar funciones de lenguaje completamente nuevas puede ser muy rápido. Antes de Hy, esto no era
muy posible para los programadores de Python ... ahora usted también puede hacer uso de las increíbles
poder (solo tenga cuidado de no apuntarlos hacia los pies)!

Hy is a Con sabor a Lisp Python
Hy se convierte al propio árbol de sintaxis abstracta de Python, por lo que pronto comenzará a encontrar que todo
el familiar poder de Python está al alcance de su mano.

Tiene acceso completo a los tipos de datos de Python y a la biblioteca estándar en Hy. Vamos a experimentar
con esto en el intérprete hy:

=> [1 2 3]
[1, 2, 3]
=> {"perro" "ladrar"
... "gato" "miau"}
...
{'perro': 'ladrar', 'gato': 'miau'}
=> (, 1 2 3)
(1, 2, 3)

Si está familiarizado con otros Lisps, es posible que le interese que Hy sea compatible con Common
Método Lisp de citar:

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

También tiene acceso a los métodos agradables de todos los tipos integrados:

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

¿Qué es esto? Sí, de hecho, esto es exactamente lo mismo que:

"fooooo" .strip ()

Así es --- ¡Lisp con notación de puntos! Si tenemos esta cadena asignada como variable,
también puede hacer lo siguiente:

(setv esta cadena "fooooo")
(esta-cadena.strip)

¿Y los condicionales ?:

(si (probar algo)
(escriba "esto es cierto")
(escriba "esto es falso"))

Como puede ver arriba, el primer argumento para if es una prueba de verdad, el segundo argumento es
el cuerpo si es verdadero, y el tercer argumento (¡opcional!) es si es falso (es decir. más).

Si necesita hacer condicionales más complejos, encontrará que no tiene elif
disponible en Hy. En su lugar, debes usar algo llamado cond. En Python, podrías hacer
algo como:

algovar = 33
si somevar> 50:
print "¡Esa variable es demasiado grande!"
elif somevar <10:
print "¡Esa variable es demasiado pequeña!"
más:
print "¡Esa variable es jussssst!"

En Hy, harías:

(condición
[(> somevar 50)
(escriba "¡Esa variable es demasiado grande!")]
[(<algunosvar 10)
(escriba "¡Esa variable es demasiado pequeña!")]
[cierto
(imprime "¡Esa variable es jussssst!")])

Lo que notarás es que cond se apaga entre una sentencia some que se ejecuta y
verificado condicionalmente para ver si es verdadero o falso, y luego un poco de código para ejecutar si se convierte
fuera a ser verdad. También notará que el más se implementa al final simplemente por
verificando para verdadero -- eso es porque verdadero siempre será cierto, así que si llegamos tan lejos,
siempre ejecuta ese!

Puede notar arriba que si tiene un código como:

(si alguna condición
(cuerpo-si-verdadero)
(cuerpo-si-falso))

¡Pero espera! ¿Qué sucede si desea ejecutar más de una instrucción en el cuerpo de una de
¿estas?

Puede hacer lo siguiente:

(si (probar algo)
(del
(escriba "esto es cierto")
(imprimir "y por qué no, sigamos hablando de lo cierto que es!))
(escriba "este sigue siendo simplemente falso"))

Puedes ver que usamos do para envolver varias declaraciones. Si está familiarizado con otros
Lisps, esto es el equivalente a programa en otro lugar.

Los comentarios comienzan con punto y coma:

(imprime "esto se ejecutará")
; (imprime "pero esto no lo hará")
(+ 1 2 3); ejecutaremos la adición, ¡pero no este comentario!

Hacer bucles no es difícil, pero tiene una estructura especial. En Python, podríamos hacer:

porque yo en distancia(10):
imprimir "'i' ahora está en" + str (i)

El equivalente en Hy sería:

(para [i (rango 10)]
(print (+ "'i' ahora está en" (str i))))

También puede importar y hacer uso de varias bibliotecas de Python. Por ejemplo:

(importar sistema operativo)

(si (os.path.isdir "/ tmp / somedir")
(os.mkdir "/ tmp / somedir / anotherdir")
(imprime "¡Oye, ese camino no está ahí!"))

Los administradores de contexto de Python ( declaraciones) se utilizan así:

(con [[f (abrir "/tmp/data.in")]]
(imprimir (. leer f)))

que es equivalente a:

con open ("/ tmp / data.in") como f:
imprimir f. leer ()

Y sí, ¡tenemos listas de comprensión! En Python puedes hacer:

probabilidades_cuadradas = [
pow (núm, 2)
para num in distancia(100)
si num% 2 == 1]

En Hy, puedes hacer esto como:

(setv probabilidades al cuadrado
(lista-comp
(pow núm 2)
(num (rango 100))
(= (% núm 2) 1)))

; Y, un ejemplo robado descaradamente de una página de Clojure:
; Hagamos una lista de todos los bloques de un tablero de ajedrez:

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

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

Python tiene soporte para varios argumentos sofisticados y argumentos de palabras clave. En Python podríamos
ver:

>>> def option_arg (pos1, pos2, keyword1 = None, keyword2 = 42):
... devuelve [pos1, pos2, palabra clave1, palabra clave2]
...
>>> opcional_arg (1, 2)
[1, 2, Ninguno, 42]
>>> opcional_arg (1, 2, 3, 4)
[1, 2, 3, 4]
>>> option_arg (palabra clave1 = 1, pos2 = 2, pos1 = 3, palabra clave2 = 4)
[3, 2, 1, 4]

Lo mismo en Hy:

=> (defn opcional-arg [pos1 pos2 y palabra clave opcional1 [palabra clave2 42]]
... [pos1 pos2 palabra clave1 palabra clave2])
=> (opcional-arg 1 2)
[1 2 Ninguno 42]
=> (opcional-arg 1 2 3 4)
[1 2 3 4]

Si está ejecutando una versión de Hy pasada 0.10.1 (por ejemplo, git master), también hay una buena nueva
sintaxis del argumento de palabra clave:

=> (opcional-arg: palabra clave1 1
...: pos2 2
...: pos1 3
...: palabra clave2 4)
[3, 2, 1, 4]

De lo contrario, siempre puede usar aplicar. Pero que es aplicar?

¿Estás familiarizado con el paso? * argumentos y ** kwargs en Python ?:

>>> argumentos = [1 2]
>>> kwargs = {"palabra clave2": 3
... "palabra clave1": 4}
>>> option_arg (* argumentos, ** kwargs)

Podemos reproducir esto con aplicar:

=> (setv args [1 2])
=> (setv kwargs {"palabra clave2" 3
... "palabra clave1" 4})
=> (aplicar kwargs de argumentos opcionales-arg)
[1, 2, 4, 3]

También hay una construcción de argumentos de palabras clave de estilo diccionario que se parece a:

(defn otro estilo [& clave {"clave1" "val1" "clave2" "val2"}]
[clave1 clave2])

La diferencia aquí es que, dado que es un diccionario, no puede confiar en ningún
ordenando los argumentos.

Hy también apoya * argumentos y ** kwargs. En Python:

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

El equivalente de Hy:

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

Finalmente, ¡por supuesto que necesitamos clases! En Python, podríamos tener una clase como:

clase FooBar (objeto):
""
Otra clase más de ejemplo
""
def __init __ (yo, x):
yo.x = x

def get_x (yo):
""
Devuelve nuestra copia de x
""
volver self.x

En Hy:

(defclass FooBar [objeto]
"Otra clase más de ejemplo"
[[--en eso--
(fn [yo mismo x]
(setv self.xx)
; Actualmente se necesita para --init-- porque __init__ necesita Ninguno
; Con suerte, esto desaparecerá :)
Ninguno)]

[obtener-x
(fn [yo]
"Devuelve nuestra copia de x"
yo.x)]])

También puede hacer atributos a nivel de clase. En Python:

clase Cliente (modelos.Modelo):
nombre = modelos.CharField (longitud_máxima = 255)
dirección = modelos.TextField ()
notas = modelos.TextField ()

En Hy:

(defclass Cliente [modelos.Modelo]
[[nombre (modelos.CharField: longitud máxima 255})]
[dirección (modelos.TextField)]
[notas (models.TextField)]])

Hy <-> Python Interoperar
¡Al importar Hy, puede usar Hy directamente desde Python!

Si guarda lo siguiente en saludos por qué:

(defn saluda a [nombre] (escribe "hola desde hy", nombre))

Luego, puede usarlo directamente desde Python, importando hy antes de importar el módulo. En
Pitón:

importar hy
saludos de importación

saludos.greet ("Foo")

También puede declarar una función en python (¡o incluso una clase!) Y usarla en Hy!

Si guarda lo siguiente en saludos.py en Python:

def greet (nombre):
print ("hola,% s"% (nombre))

Puedes usarlo en Hy:

(saludos de importación)
(.greet saludos "foo")

Para usar argumentos de palabras clave, puede usar en saludos.py:

def greet (nombre, título = "Señor"):
print ("Saludos,% s% s"% (título, nombre))

(saludos de importación)
(.greet saludos "Foo")
(.saludos saludos "Foo" "Darth")
(aplicar (. saludos saludar) ["Foo"] {"title" "Lord"})

Que daría como resultado:

Saludos, Sir Foo

Saludos, Darth Foo

Saludos, Lord Foo

¡Protips!
Hy también incluye algo conocido como "macro de subprocesos", una característica muy interesante de
De Clojure. La "macro de subprocesos" (escrita como ->) se utiliza para evitar el anidamiento profundo de
expresiones

La macro de subprocesos inserta cada expresión en el primer argumento de la siguiente expresión
posición.

Tomemos el clásico:

(bucle (imprimir (eval (leer))))

En lugar de escribirlo así, podemos escribirlo de la siguiente manera:

(-> (leer) (eval) (imprimir) (bucle))

Ahora, usando pitón-sh, podemos mostrar cómo la macro de subprocesos (debido a la configuración de python-sh)
se puede utilizar como una pipa:

=> (importar [sh [cat grep wc]])
=> (-> (gato "/ usr / compartir / dictado / palabras") (grep "-E" "^ hy") (wc "-l"))
210

Lo cual, por supuesto, se expande a:

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

Mucho más legible, ¿no? ¡Usa la macro de enhebrado!

HY ESTILO GUÍAS

"Sabes, Ministro, no estoy de acuerdo con Dumbledore en muchos aspectos ... pero no puedes negar que está
tiene estilo ... ”- Phineas Nigellus Black, Harry Alfarero y las Ordenar of las Phoenix

La guía de estilo Hy pretende ser un conjunto de reglas básicas para Hyve (sí, la comunidad Hy
se enorgullece de agregar Hy a todo) para escribir código Hy idiomático. Hy deriva mucho
de Clojure y Common Lisp, manteniendo siempre la interoperabilidad de Python.

Preludio
El Tao of Hy
Ummon preguntó al monje principal: "¿Sobre qué sutra estás dando una conferencia?"
"El Sutra del Nirvana".
"El Sutra del Nirvana tiene las Cuatro Virtudes, ¿no es así?"
"Tiene."
Ummon preguntó, tomando una taza, "¿Cuántas virtudes tiene esto?"
"Ninguno en absoluto", dijo el monje.
"Pero los antiguos dijeron que sí, ¿no es así?" dijo Ummon.
"¿Qué piensas de lo que dijeron?"
Ummon golpeó la taza y preguntó: "¿Entiendes?"
"No", dijo el monje.
"Entonces", dijo Ummon, "será mejor que continúes con tus conferencias sobre el sutra".
- la macro (koan)

A continuación, se ilustra una breve lista de decisiones de diseño que se tomaron para la realización de
Hy.

· Parece un Lisp; DTRT con él (por ejemplo, los guiones se convierten en guiones bajos, las orejeras se convierten en
todo en mayúsculas).

· Seguimos siendo Python. La mayoría de los componentes internos se traducen 1: 1 en componentes internos de Python.

· Utilice Unicode en todas partes.

· Arreglar las malas decisiones en Python 2 cuando podamos (ver verdadera_división).

· En caso de duda, confíe en Python.

· Si aún no está seguro, aplíquese a Clojure.

· Si está aún más inseguro, consulte Common Lisp.

· Tenga en cuenta que no somos Clojure. No somos Common Lisp. Somos Python homoicónico, con
bits extra que tienen sentido.

Disposición & sangría
· Evite los espacios al final. ¡Apestan!

· La sangría debe ser de 2 espacios (sin tabulaciones duras), excepto cuando coincida con la sangría de
la línea anterior.

;; Bueno (y preferido)
(defn fib [n])
(si (<= n 2)
n
(+ (mentira (- n 1)) (mentira (- n 2)))))

;; Todavía está bien
(defn fib [n])
(si (<= n 2) n (+ (fib (- n 1)) (fib (- n 2)))))

;; Todavía está bien
(defn fib [n])
(si (<= n 2)
n
(+ (mentira (- n 1)) (mentira (- n 2)))))

;; Histéricamente ridículo
(defn fib [n])
(si (<= n 2)
n ;; sí, me encanta presionar la tecla espaciadora al azar
(+ (mentira (- n 1)) (mentira (- n 2)))))

· Los paréntesis deben nunca quedarse solos, tristes y solitarios en su propia línea.

;; Bueno (y preferido)
(defn fib [n])
(si (<= n 2)
n
(+ (mentira (- n 1)) (mentira (- n 2)))))

;; Histéricamente ridículo
(defn fib [n])
(si (<= n 2)
n
(+ (mentira (- n 1)) (mentira (- n 2)))
)
); GAH, QUEMADLO CON FUEGO

· Alinear verticalmente dejar Bloques

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

· Los comentarios en línea deben estar a dos espacios del final del código; siempre deben tener un
espacio entre el carácter de comentario y el inicio del comentario. Además, trate de no
comenta lo obvio.

;; Bien
(setv ind (dec x)); la indexación comienza desde 0

;; Cumple con el estilo pero solo dice lo obvio
(setv ind (dec x)); establece el índice en x-1

;; Malo
(setv ind (dec x)); escribir palabras por diversión

Codificación Estilo
· Como convención, trate de no utilizar def para cualquier otra cosa que no sean variables globales; usar setv
funciones internas, bucles, etc.

;; Bueno (y preferido)
(def * límite * 400000)

(defn fibs [ab]
(aunque cierto
(rendimiento a)
(setv (, ab) (, b (+ ab)))))

;; Malo (y no preferido)
(defn fibs [ab]
(aunque cierto
(rendimiento a)
(def (, ab) (, b (+ ab)))))

· No utilice la sintaxis de expresión s donde se pretende la sintaxis vectorial. Por ejemplo, el hecho
que el primero de estos dos ejemplos funciona es solo porque el compilador no es demasiado
estricto. En realidad, la sintaxis correcta en lugares como este es la última.

;; Malo (y malvado)
(defn foo (x) (imprime x))
(foto 1)

;; Bueno (y preferido)
(defn foo [x] (imprimir x))
(foto 1)

· Utilice la macro de enhebrado o las macros de cola de enhebrado cuando encuentre profundamente anidado
Expresiones-s. Sin embargo, sea prudente al usarlos. Úselos cuando la claridad y
mejora la legibilidad; no construya expresiones complicadas y difíciles de entender.

;; Privilegiado
(def * nombres *
(con [f (abre "nombres.txt")]
(-> (.read f) (.strip) (.replace "\" "" ") (.split", ") (ordenado))))

;; No tan bien
(def * nombres *
(con [f (abre "nombres.txt")]
(ordenado (.split "," (.replace "\" "" "(.strip (.read f)))))))

;; probablemente no es una buena idea
(defn cuadrado? [x]
(- >> 2 (pow (int (sqrt x))) (= x)))

· Se prefiere la notación de puntos al estilo Clojure sobre la llamada directa del método del objeto,
aunque ambos seguirán siendo compatibles.

;; Bien
(con [fd (open "/ Etc / passwd")]
(imprimir (.readlines fd)))

;; No tan bien
(con [fd (open "/ Etc / passwd")]
(imprimir (fd.readlines)))

Conclusión
“Las modas se desvanecen, el estilo es eterno” —Yves Saint Laurent

Esta guía es solo un conjunto de pautas de la comunidad y, obviamente, las pautas de la comunidad
no tiene sentido sin una comunidad activa. Las contribuciones son bienvenidas. Únase a nosotros en #hy in
freenode, bloguea sobre ello, tuitea sobre ello y, lo más importante, diviértete con Hy.

Muchas Gracias
· Esta guía está muy inspirada en @pablotag entrada del blog Hy Supervivencia Guía

· Los Clojure Estilo Guía

DOCUMENTACIÓN ÍNDICE

Contenido:

Comando línea Interfaz
hy
Comando línea Opciones
-c
Ejecute el código Hy en comando.

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

-i
Ejecute el código Hy en comando, luego permanezca en REPL.

-m
Ejecute el código Hy en módulo, incluyendo definir si está definido.

El -m bandera termina la lista de opciones para que todos los argumentos después de la módulo nombre
se pasan al módulo en sistema.argv.

Nuevo en la versión 0.10.2.

--espiar Imprima código Python equivalente antes de ejecutar. Por ejemplo:

=> (defn salutationsnm [nombre] (print (+ "Hy" nombre "!")))
def salutationsnm (nombre):
return print (((u'Hy '+ nombre) + u'! '))
=> (salutationsnm "YourName")
salutationsnm (u'YourName ')
¡Hy YourName!
=>

Nuevo en la versión 0.9.11.

--mostrar-trazamientos
Imprima rastreos extendidos para excepciones Hy.

Nuevo en la versión 0.9.12.

-v Imprima el número de versión de Hy y salga.

hyc
Comando línea Opciones
expediente[, archivoN]
Compile el código Hy en el código de bytes de Python. Por ejemplo, guarde el siguiente código como
hyname.hy:

(defn hy-hy [nombre]
(print (+ "Hy" nombre "!")))

(hy-hy "Afroman")

Entonces corre:

$ hyc hynombre.hy
$ python hyname.pyc
¡Hy Afroman!

hy2py
Nuevo en la versión 0.10.1.

Comando línea Opciones
-s

--con fuente
Muestre la estructura de la fuente analizada.

-a

--con-ast
Muestre el AST generado.

-notario público

--sin-python
No muestre el código Python generado a partir del AST.

Hy (la idioma)
ADVERTENCIA:
Esto está incompleto; considere contribuir al esfuerzo de documentación.

TEORÍA of Hy
Hy mantiene, por encima de todo lo demás, una compatibilidad del 100% en ambas direcciones con Python
sí mismo. Todo el código de Hy sigue algunas reglas simples. Memoriza esto, ya que vendrá
práctico.

Estas reglas ayudan a garantizar que el código Hy sea idiomático y se pueda conectar en ambos idiomas.

· Los símbolos en las orejeras se traducirán a la versión en mayúsculas de esa cadena. Para
ejemplo, foo se convertirá FOO.

· Las entidades UTF-8 se codificarán utilizando punycode y prefijado con hy_. Por ejemplo, ⚘
se convertirá hy_w7h, ♥ se convertirá hy_g6hy yo ♥ u se convertirá hy_iu_t0x.

· Los símbolos que contienen guiones se reemplazarán por guiones bajos. Por ejemplo,
plantilla de renderizado se convertirá plantilla_de_procesamiento. Esto significa que los símbolos con guiones
sombrear sus equivalentes de subrayado y viceversa.

Construidos
Hy presenta una serie de formas especiales que se utilizan para ayudar a generar Python AST correcto.
Los siguientes son formularios "especiales", que pueden tener un comportamiento ligeramente inesperado en
algunas situaciones.

.
Nuevo en la versión 0.10.0.

. se utiliza para realizar acceso a atributos en objetos. Utiliza un pequeño DSL para permitir una rápida
acceso a atributos y elementos en una estructura de datos anidada.

Por ejemplo,

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

Compila hasta:

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

. compila su primer argumento (en el ejemplo, foo) como el objeto sobre el que realizar la
desreferencia de atributo. Utiliza símbolos desnudos como atributos para acceder (en el ejemplo, de caramelos,
baz, frotar) y compila el contenido de listas (en el ejemplo, [(+ 1 2)]) para indexación.
Otros argumentos arrojan un error de compilación.

El acceso a atributos desconocidos arroja un Error de atributo. El acceso a claves desconocidas arroja un
Error de índice (en listas y tuplas) o un Error de clave (en diccionarios).

->
-> (O la enhebrar macro) se utiliza para evitar el anidamiento de expresiones. La macro de enhebrado
inserta cada expresión en el primer lugar del argumento de la siguiente expresión. El seguimiento
el código demuestra esto:

=> (defn salida [ab] (imprimir ab))
=> (-> (+ 4 6) (salida 5))
10 5

- >>
- >> (O la enhebrar cola macro) es similar al enhebrar macro, pero en lugar de
insertando cada expresión en el primer argumento de la siguiente expresión, la agrega como el
último argumento. El siguiente código demuestra esto:

=> (defn salida [ab] (imprimir ab))
=> (- >> (+ 4 6) (salida 5))
5 10

aplicar
aplicar se utiliza para aplicar una lista opcional de argumentos y un diccionario opcional de kwargs
a una función.

Uso: (solicitar nombre-fn [argumentos] [kwargs])

Ejemplos:

(definición thunk []
"¿Por qué?")

(aplicar thunk)
; => "por ahí"

(defn compra total [importe del precio y [tarifas 1.05] [iva 1.1]]
(* precio importe tarifas iva))

(aplicar compra total [10 15])
; => 173.25

(aplique la compra total [10 15] {"iva" 1.05})
; => 165.375

(aplicar compra total [] {"precio" 10 "monto" 15 "iva" 1.05})
; => 165.375

y
y se utiliza en expresiones lógicas. Se necesitan al menos dos parámetros. Si todos los parámetros
evaluar a ¿Editas con tu equipo de forma remota?, se devuelve el último parámetro. En cualquier otro caso, el primer valor falso
Será devuelto. Uso de ejemplo:

=> (y Verdadero Falso)
Falso

=> (y Verdadero Verdadero)
¿Editas con tu equipo de forma remota?

=> (y Verdadero 1)
1

=> (y Verdadero [] Falso Verdadero)
[]

NOTA:
y cortocircuitos y deja de evaluar los parámetros tan pronto como el primer falso es
encontrado.

=> (y Falso (imprime "hola"))
Falso

afirmar
afirmar se utiliza para verificar las condiciones mientras se ejecuta el programa. Si la condición no es
conocido, un Error de aserción es elevado. afirmar puede tomar uno o dos parámetros. El primero
El parámetro es la condición a verificar, y debe evaluarse como ¿Editas con tu equipo de forma remota? or Falso.
segundo parámetro, opcional, es una etiqueta para la aserción, y es la cadena que será
criado con el Error de aserción. Por ejemplo:

(aseverar (= valor-esperado variable))

(afirmar falso)
; Error de aserción

(aseverar (= 1 2) "uno debe ser igual a dos")
; AssertionError: uno debe ser igual a dos

Assoc
Assoc se utiliza para asociar una clave con un valor en un diccionario o para establecer un índice de una lista
a un valor. Se necesitan al menos tres parámetros: el datos estructura para ser modificado, un clave
or índice, Y un propuesta de. Si se utilizan más de tres parámetros, se asociará en pares.

Ejemplos de uso:

=> (dejar [[colección {}]]
... (colección asociada "Perro" "Bark")
... (colección impresa))
{u'Dog ': u'Bark'}

=> (dejar [[colección {}]]
... (colección asociada "Perro" "Ladrido" "Gato" "Miau")
... (colección impresa))
{u'Cat ': u'Meow', u'Dog ': u'Bark'}

=> (deje [[colección [1 2 3 4]]]
... (colección asociada 2 Ninguno)
... (colección impresa))
[1, 2, Ninguno, 4]

NOTA:
Assoc modifica la estructura de datos en su lugar y devuelve Ninguna.

romper
romper se utiliza para salir de un bucle. Termina el ciclo inmediatamente. El seguimiento
ejemplo tiene un infinito mientras bucle que finaliza tan pronto como el usuario ingresa k.

(mientras es Verdadero (si (= "k" (entrada sin procesar "?"))
(rotura)
(imprime "Inténtalo de nuevo")))

cond
cond se puede utilizar para construir anidados if declaraciones. El siguiente ejemplo muestra el
relación entre la macro y su expansión:

(cond [condición-1 resultado-1]
[condición-2 resultado-2])

(si condición-1 resultado-1
(si condición-2 resultado-2))

Como se muestra a continuación, solo se ejecuta el primer bloque de resultados coincidentes.

=> (defn check-value [valor]
... (cond [(<valor 5) (imprimir "el valor es menor que 5")]
... [(= valor 5) (imprimir "el valor es igual a 5")]
... [(> valor 5) (imprimir "el valor es mayor que 5")]
... [True (print "valor es algo que no debería ser")]))

=> (valor de verificación 6)
el valor es mayor que 5

continue
continue devuelve la ejecución al inicio de un bucle. En el siguiente ejemplo,
(efecto secundario1) se llama para cada iteración. (efecto secundario2), sin embargo, solo se solicita
todos los demás valores de la lista.

;; asumiendo que (efecto secundario1) y (efecto secundario2) son funciones y
;; colección es una lista de valores numéricos

(para [x colección]
(del
(efecto secundario1 x)
(si (% x 2)
(Seguir))
(efecto secundario2 x)))

dict-comp
dict-comp se utiliza para crear diccionarios. Se necesitan tres o cuatro parámetros. El primero
dos parámetros son para controlar el valor de retorno (par clave-valor) mientras que el tercero es
se utiliza para seleccionar elementos de una secuencia. El cuarto y opcional parámetro se puede utilizar para
filtra algunos de los elementos de la secuencia en función de una expresión condicional.

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

do / programa
do y programa se utilizan para evaluar cada uno de sus argumentos y devolver el último. Regreso
los valores de cualquier otro argumento que no sea el último se descartan. Se puede utilizar en lambda or
lista-comp para realizar una lógica más compleja como se muestra en uno de los siguientes ejemplos.

Algunos ejemplos de uso:

=> (si es cierto
... (hacer (imprimir "Efectos secundarios de rock!")
... (escriba "¡Sí, de verdad!")))
¡Los efectos secundarios son increíbles!
¡Si, en serio!

;; asumiendo que (efecto secundario) es una función que queremos llamar para cada
;; y todos los valores de la lista, pero cuyo valor de retorno no nos importa
=> (list-comp (do (efecto secundario x)
... (si (<x 5) (* 2 x)
... (* 4x)))
... (x (rango 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do puede aceptar cualquier número de argumentos, de 1 a n.

def / setv
def y setv se utilizan para vincular un valor, objeto o función a un símbolo. Por ejemplo:

=> (def nombres ["Alice" "Bob" "Charlie"])
=> (imprimir nombres)
[u'Alice ', u'Bob', u'Charlie ']

=> (contador setv (fn [artículo de colección] (.contar artículo de colección)))
=> (contador [1 2 3 4 5 2 3] 2)
2

defclase
Las nuevas clases se declaran con defclase. Puede tomar dos parámetros opcionales: un vector
definir una posible superclase y otro vector que contenga atributos de la nueva
class como dos vectores de elementos.

(defclass nombre-clase [super-clase-1 super-clase-2]
[[valor de atributo]])

Tanto los valores como las funciones se pueden vincular en la nueva clase como se muestra en el siguiente ejemplo:

=> (defclass Cat []
... [[edad Ninguno]
... [color "blanco"]
... [hablar (fn [self] (imprimir "Miau"))]])

=> (def spot (gato))
=> (setv spot.colour "Negro")
'Negro'
=> (.speak spot)
Miau

definir / difunto
definir y difunto las macros se utilizan para definir funciones. Toman tres parámetros: el nombre
de la función a definir, un vector de parámetros, y la cuerpo de la función:

(defn nombre [parámetros] cuerpo)

Los parámetros pueden tener las siguientes palabras clave delante de ellos:

&Opcional
El parámetro es opcional. El parámetro se puede dar como una lista de dos elementos, donde el
el primer elemento es el nombre del parámetro y el segundo es el valor predeterminado. El parámetro
también se puede dar como un solo artículo, en cuyo caso el valor predeterminado es Ninguna.

=> (defn valor-total [valor y opcional [impuesto al valor agregado 10]]
... (+ (/ (* valor de impuesto al valor agregado) 100) valor))

=> (valor total 100)
110.0

=> (valor total 100 1)
101.0

&llave

y kwargs
El parámetro contendrá 0 o más argumentos de palabras clave.

Los siguientes ejemplos de código definen una función que imprimirá todas las palabras clave
argumentos y sus valores.

=> (defn parámetros de impresión [& kwargs kwargs]
... (para [(, kv) (.items kwargs)] (imprimir kv)))

=> (aplicar parámetros de impresión [] {"parámetro-1" 1 "parámetro-2" 2})
parámetro-2 2
parámetro-1 1

&descansar El parámetro contendrá 0 o más argumentos posicionales. Ningún otro posicional
los argumentos se pueden especificar después de éste.

El siguiente ejemplo de código define una función a la que se le puede dar 0 an numérico
parámetros. Luego suma todos los números impares y resta todos los números pares.

=> (defn suma en zig-zag [y números de descanso]
(deje [[números impares (lista-comp x [x números] (impares? x))]
[números pares (lista-comp x [x números] (pares? x))]]
(- (suma de números impares) (suma de números pares))))

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

alias defn / alias-defun
Nuevo en la versión 0.10.0.

El alias defn y alias-defun las macros son muy parecidas definir, con la distinción de que
en lugar de definir una función con un solo nombre, estos también pueden definir alias. Otro
que tomar una lista de símbolos para los nombres de las funciones como primer parámetro, alias defn y
alias-defun no son diferentes de definir y difunto.

=> (defn-alias [alias del nombre principal] []
... (imprime "¡Hola!"))
=> (nombre-principal)
"¡Hola!"
=> (alias)
"¡Hola!"

definir
Nuevo en la versión 0.10.1.

El definir macro define una función principal que se llama inmediatamente con sistema.argv as
argumentos si y solo si este archivo se está ejecutando como un script. En otras palabras, esto:

(defmain [& rest args])
(hacer-algo-con argumentos))

es el equivalente de:

def principal (* argumentos):
hacer_algo_con (argumentos)
volver 0

if __name__ == "__main__":
importación de sistemas
retval = main (* sys.arg)

si es instancia (retval, int):
sys.exit (retval)

Tenga en cuenta que, como puede ver arriba, si devuelve un número entero de esta función, esto será
utilizado como estado de salida para su secuencia de comandos. (Python sale por defecto del estado 0 de lo contrario,
lo que significa que todo está bien!)

(Ya que (sys.salida 0) no se ejecuta explícitamente en el caso de un retorno no entero de
definir, es una buena idea poner (definitivamente) como la última pieza de código en su archivo).

definiciónmacro
definiciónmacro se utiliza para definir macros. El formato general es (definición macro nombre [parámetros]
expr).

El siguiente ejemplo define una macro que se puede utilizar para intercambiar el orden de los elementos en el código,
permitiendo al usuario escribir código en notación infija, donde el operador está entre los
operandos.

=> (defmacro infix [código]
... (cuasiquote (
... (quitar comillas (obtener el código 1))
... (quitar comillas (obtener el código 0))
... (quitar comillas (obtener el código 2)))))

=> (infijo (1 + 1))
2

alias defmacro
alias defmacro se utiliza para definir macros con varios nombres (alias). El formato general
is (defmacro-alias [nombres] [parámetros] expr). Crea múltiples macros con el mismo
lista de parámetros y cuerpo, debajo de la lista de nombres especificada.

El siguiente ejemplo define dos macros, las cuales permiten al usuario escribir código en
notación infija.

=> (defmacro-alias [infix infi] [código]
... (cuasiquote (
... (quitar comillas (obtener el código 1))
... (quitar comillas (obtener el código 0))
... (quitar comillas (obtener el código 2)))))

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

defmacro / g!
Nuevo en la versión 0.9.12.

defmacro / g! es una versión especial de definiciónmacro que se utiliza para generar automáticamente genio
para cualquier símbolo que comience con g!.

Por ejemplo, Georgia se convertiría (gensimo "a").

VEA ADEMÁS:
Sección using-gensym

defraudador
Nuevo en la versión 0.9.12.

defraudador define una macro de lector, lo que le permite reestructurar o modificar la sintaxis.

=> (defreader ^ [expr] (print expr))
=> # ^ (1 2 3 4)
(1 2 3 4)
=> # ^ "Hola"
"Hola"

VEA ADEMÁS:
Macros del lector de sección

de los
Nuevo en la versión 0.9.12.

de los elimina un objeto del espacio de nombres actual.

=> (setv foo 42)
=> (del foo)
=> foo
Rastreo (llamadas recientes más última):
Expediente " ", línea 1, en
NameError: el nombre 'foo' no está definido

de los también puede eliminar objetos de asignaciones, listas y más.

=> (prueba setv (lista (rango 10)))
=> prueba
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (del (prueba de corte 2 4)) ;; eliminar elementos de 2 a 4 excluidos
=> prueba
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "bar"})
=> dic
{"foo": "bar"}
=> (del (obtener dic "foo"))
=> dic
{}

hacer para
Nuevo en la versión 0.10.1.

hacer para se utiliza para simplificar una secuencia de llamadas a métodos a un objeto.

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

=> (colección setv [])
=> (.append colección 1)
=> (.append colección 2)
=> (colección .reverse)
=> colección
[2 1]

eval
eval evalúa una expresión entre comillas y devuelve el valor.

=> (eval '(imprimir "Hola mundo"))
"Hola Mundo"

evaluar y compilar
evaluar-cuando-compilar
la primera / de
la primera y de son macros para acceder al primer elemento de una colección:

=> (primero (rango 10))
0

para
para se utiliza para llamar a una función para cada elemento de una lista o vector. Los resultados de cada
se descartan y las para devoluciones de expresión Ninguna en lugar de. El código de ejemplo itera
Más de -- y para cada elementos in -- llama al Efecto secundario funcionar con
elementos como su argumento:

;; asumiendo que (efecto secundario) es una función que toma un solo parámetro
(para [colección de elementos] (elemento de efecto secundario))

;; para puede tener un bloque else opcional
(para [colección de elementos] (elemento de efecto secundario)
(más (efecto secundario-2)))

La opción más El bloque solo se ejecuta si el para El bucle termina normalmente. Si el
la ejecución se detiene con romper, la más el bloque no se ejecuta.

=> (para [elemento [1 2 3]] (si (<elemento 3)
... (elemento de impresión)
... (rotura))
... (else (imprimir "bucle terminado")))
1
2

=> (para [elemento [1 2 3]] (si (<elemento 4)
... (elemento de impresión)
... (rotura))
... (else (imprimir "bucle terminado")))
1
2
3
bucle terminado

genexpr
genexpr se utiliza para crear expresiones generadoras. Se necesitan dos o tres parámetros. los
El primer parámetro es la expresión que controla el valor de retorno, mientras que el segundo se usa
para seleccionar elementos de una lista. El tercer parámetro opcional se puede utilizar para filtrar
algunos de los elementos de la lista se basan en una expresión condicional. genexpr es parecido a
lista-comp, excepto que devuelve un iterable que evalúa los valores uno por uno en lugar de
evaluándolos de inmediato.

=> (def colección (rango 10))
=> (def filtrado (genexpr x [x colección] (par? x)))
=> (lista filtrada)
[0, 2, 4, 6, 8]

genio
Nuevo en la versión 0.9.12.

genio se utiliza para generar un símbolo único que permite escribir macros sin
choques accidentales de nombres de variables.

=> (gensym)
u ': G_1235'

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

VEA ADEMÁS:
Sección using-gensym

obtener
obtener se utiliza para acceder a elementos individuales en listas y diccionarios. obtener toma dos parámetros:
las datos estructura y del índice or clave del artículo. Luego devolverá el correspondiente
valor del diccionario o de la lista. Uso de ejemplo:

=> (dejar [[animales {"perro" "ladrar" "gato" "miau"}]
... [números ["cero" "uno" "dos" "tres"]]]
... (imprimir (obtener animales "perro"))
... (imprimir (obtener los números 2)))
ladrido
dos

NOTA:
obtener genera un KeyError si se consulta un diccionario para una clave no existente.

NOTA:
obtener genera un IndexError si se consulta una lista o una tupla para un índice que está fuera de
límites.

global
global se puede utilizar para marcar un símbolo como global. Esto permite al programador asignar un
valor a un símbolo global. La lectura de un símbolo global no requiere la global palabra clave -
solo asignando lo hace.

El siguiente ejemplo muestra cómo el símbolo global a se le asigna un valor en una función y
se imprime posteriormente en otra función. Sin el global palabra clave, la segunda función
habría lanzado un Error de nombre.

(defn conjunto-a [valor]
(mundial a)
(establecer un valor))

(defn imprimir-a []
(imprimir una))

(conjunto-a 5)
(imprimir-a)

if / que no
Nuevo en la versión 0.10.0: if-not

if se utiliza para seleccionar condicionalmente el código que se ejecutará. Tiene que contener una condición
bloque y el bloque que se ejecutará si el bloque de condición se evalúa como ¿Editas con tu equipo de forma remota?. Opcionalmente,
puede contener un bloque final que se ejecuta en caso de que la evaluación de la condición sea
Falso.

que no es similar, pero el segundo bloque se ejecutará cuando la condición falle mientras
el tercer y último bloque se ejecuta cuando la prueba tiene éxito, el orden opuesto de if.

Ejemplo de uso:

(si (¿queda dinero? ¿Cuenta)
(imprime "vamos de compras")
(imprime "vamos a trabajar"))

(si no (¿dinero restante? ¿Cuenta)
(imprime "vamos a trabajar")
(imprime "vamos de compras"))

Se respeta la veracidad de Python. Ninguna, Falso, cero de cualquier tipo numérico, una secuencia vacía,
y un diccionario vacío se consideran Falso; todo lo demás se considera ¿Editas con tu equipo de forma remota?.

ceceo-si / lif y ceceo-si-no / no vida
Nuevo en la versión 0.10.0.

Nuevo en la versión 0.10.2: lisp-if-not / lif-not

Para los que prefieren un más Lispy if cláusula, tenemos ceceo-sio lif. Esto , solamente considera
Ninguna / cero ser falso! Todos los demás valores de Python "falsos" se consideran verdaderos.
Por el contrario, tenemos ceceo-si-no y no vida en paralelo a if y que no que se invierte
la comparación.

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

; Equivalente pero más corto
=> (lif Verdadero "verdadero" "falso")
"cierto"
=> (de por vida "verdadero" "falso")
"falso"
=> (lif-not None "verdadero" "falso")
"cierto"

importar
importar se usa para importar módulos, como en Python. Hay varias formas de importar podemos
ser usado.

;; Importa cada uno de estos módulos
;;
;; Pitón:
;; importar sys
;; importar ruta de sistema operativo
(importar sys os.path)

;; Importar desde un módulo
;;
;; Python: desde os.path existe la importación, isdir, isfile
(importar [os.path [existe isdir isfile]])

;; Importar con un alias
;;
;; Python: importar sys como sistema
(importar [sys: como sistema])

;; Puede enumerar tantas importaciones como desee de diferentes tipos.
(importar [tests.resources [kwtest function-with-a-dash]]
[os.path [existe isdir isfile]]
[sys: como sistema])

;; Importar todas las funciones del módulo al espacio de nombres actual
(importar [sys [*]])

lambda / fn
lambda y fn se puede utilizar para definir una función anónima. Los parámetros son similares a
definir: el primer parámetro es un vector de parámetros y el resto es el cuerpo del
función. lambda devuelve una nueva función. En el siguiente ejemplo, una función anónima
se define y se pasa a otra función para filtrar la salida.

=> (def people [{: name "Alice": age 20}
... {: nombre "Bob": 25 años}
... {: nombre "Charlie": 50 años}
... {: nombre "Dave": 5 años}])

=> (defn display-people [filtro de personas]
... (para [persona personas] (si (filtrar persona) (letra de imprenta (: nombre de la persona)))))

=> (mostrar-personas personas (fn [persona] (<(: persona de edad) 25)))
Alicia
David

Al igual que en las definiciones de funciones normales, si el primer elemento del cuerpo es una cadena,
sirve como una cadena de documentación. Esto es útil para proporcionar cadenas de documentación a los métodos de clase.

=> (setv veces-tres
... (fn[x]
... "Multiplica la entrada por tres y devuelve el resultado".
... (*x3)))

Esto se puede confirmar a través de la función incorporada de Python ayuda función:

=> (ayuda veces-tres)
Ayuda sobre la función times_three:

veces_tres (x)
Multiplica la entrada por tres y devuelve el resultado.
(FIN)

pasado
Nuevo en la versión 0.10.2.

pasado se puede utilizar para acceder al último elemento de una colección:

=> (último [2 4 6])
6

dejar
dejar se utiliza para crear variables de ámbito léxico. Se crean al comienzo de la
dejar forma y deja de existir después de la forma. El siguiente ejemplo muestra esto
comportamiento:

=> (deje [[x 5]] (imprima x)
... (deje [[x 6]] (imprima x))
... (imprimir x))
5
6
5

El dejar La macro toma dos parámetros: un vector que define las variables y del cuerpo que se pone
ejecutado. las variables es un vector donde cada elemento es una sola variable o un vector
definir un par de valores variables. En el caso de una sola variable, se le asigna un valor
Ninguna; de lo contrario, se utiliza el valor proporcionado.

=> (deje [x [y 5]] (imprima xy))
Ninguno 5

lista-comp
lista-comp realiza listas por comprensión. Se necesitan dos o tres parámetros. El primero
parámetro es la expresión que controla el valor de retorno, mientras que el segundo se utiliza para
seleccionar elementos de una lista. El tercer y opcional parámetro se puede utilizar para filtrar algunos
de los elementos de la lista según una expresión condicional. Algunos ejemplos:

=> (def colección (rango 10))
=> (list-comp x [x colección])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

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

no
no se utiliza en expresiones lógicas. Toma un solo parámetro y devuelve un invertido
valor de verdad. Si ¿Editas con tu equipo de forma remota? se da como parámetro, Falso será devuelto, y viceversa.
Ejemplo de uso:

=> (no es cierto)
Falso

=> (no falso)
¿Editas con tu equipo de forma remota?

=> (no Ninguno)
¿Editas con tu equipo de forma remota?

or
or se utiliza en expresiones lógicas. Se necesitan al menos dos parámetros. Devolverá el
primer parámetro no falso. Si no existe tal valor, se devolverá el último parámetro.

=> (o Verdadero Falso)
¿Editas con tu equipo de forma remota?

=> (y falso falso)
Falso

=> (y Falso 1 Verdadero Falso)
1

NOTA:
or cortocircuitos y deja de evaluar los parámetros tan pronto como el primer valor verdadero es
encontrado.

=> (o Verdadero (escribe "hola"))
¿Editas con tu equipo de forma remota?

Imprimir
Imprimir se utiliza para mostrar en pantalla. Uso de ejemplo:

(imprimir "¡Hola mundo!")

NOTA:
Imprimir siempre vuelve Ninguna.

cuasiquote
cuasiquote le permite citar un formulario, pero también evaluar expresiones selectivamente.
Expresiones dentro de un cuasiquote se puede evaluar de forma selectiva utilizando unquote (~). La
La forma evaluada también se puede empalmar usando empalme sin comillas (~@). Quasiquote también puede ser
escrito usando la comilla inversa`) símbolo.

;; sea ​​`qux 'una variable con valor (bar baz)
`(foo ~ qux)
; equivalente a '(foo (bar baz))
`(foo ~ @ qux)
; equivalente a '(foo bar baz)

cotización inicial
cotización inicial devuelve el formulario que se le ha pasado sin evaluarlo. cotización inicial alternativamente puede ser
escrito usando el apóstrofe') símbolo.

=> (setv x '(imprimir "Hola mundo"))
; la variable x se establece en expresión y no se evalúa
=> x
(u'print 'u'Hello World')
=> (eval x)
Hola Mundo

exigir
exigir se utiliza para importar macros de un módulo determinado. Toma al menos un parámetro
especificando el módulo cuyas macros se deben importar. Se pueden importar varios módulos
con un solo exigir.

El siguiente ejemplo importará macros desde módulo-1 y módulo-2:

(requiere módulo-1 módulo-2)

resto / cdr
resto y cdr devuelve la colección pasada como argumento sin el primer elemento:

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

conjunto-comp
conjunto-comp se utiliza para crear conjuntos. Se necesitan dos o tres parámetros. El primer parámetro es
para controlar el valor de retorno, mientras que el segundo se utiliza para seleccionar elementos de un
secuencia. El tercer parámetro opcional se puede utilizar para filtrar algunos de los elementos en
la secuencia basada en una expresión condicional.

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

rebanada
rebanada se puede utilizar para tomar un subconjunto de una lista y crear una nueva lista a partir de ella. La forma
toma al menos un parámetro que especifica la lista a dividir. Se pueden configurar dos parámetros opcionales
utilizado para dar la posición inicial y final del subconjunto. Si no se suministran,
valor predeterminado de Ninguna se utilizará en su lugar. El tercer parámetro opcional se utiliza para
paso de control entre los elementos.

rebanada sigue las mismas reglas que su contraparte de Python. Se cuentan los índices negativos
comenzando desde el final de la lista. Algunos ejemplos de uso:

=> (def colección (rango 10))

=> (colección de cortes)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=> (colección de rebanadas 5)
[5, 6, 7, 8, 9]

=> (colección de rebanadas 2 8)
[2, 3, 4, 5, 6, 7]XNUMX

=> (colección de rodajas 2 8 2)
[2, 4, 6]

=> (colección de cortes -4-2)
[6, 7]

lanzar / aumento
El lanzar or aumento Los formularios se pueden utilizar para generar un Excepción en tiempo de ejecución. Uso de ejemplo:

(lanzar)
; re-rase la última excepción

(lanzar IOError)
; Lanzar un IOError

(lanzar (IOError "foobar"))
; Lanzar un IOError ("foobar")

lanzar puede aceptar un solo argumento (un Excepción clase o instancia) o sin argumentos para
resucita el último Excepción.

try
El try El formulario se utiliza para iniciar un try / coger cuadra. El formulario se utiliza de la siguiente manera:

(intentar
(función propensa a errores)
(captura [e ZeroDivisionError] (imprime "División por cero"))
(si no (imprime "sin errores"))
(finalmente (escriba "todo listo")))

try debe contener al menos uno coger bloque, y opcionalmente puede incluir un más or finalmente
cuadra. Si se genera un error con un bloque catch coincidente durante la ejecución de
función propensa a errores, Que coger se ejecutará el bloque. Si no surgen errores, el más
se ejecuta el bloque. El finalmente bloque se ejecutará en último lugar independientemente de si un bloque
se generó un error.

a menos que
El a menos que macro es una forma abreviada de escribir una if declaración que comprueba si el dado
condicional es Falso. A continuación se muestra la expansión de esta macro.

(a menos que una declaración condicional)

(si es condicional
Ninguna
(hacer declaración))

unquote
Dentro de una forma de cuasicuotas, unquote fuerza la evaluación de un símbolo. unquote tiene el alias de
la tilde~) símbolo.

(nombre definido "Cuddles")
(quasiquote (= nombre (nombre sin comillas)))
; => (u '=' u'name 'u'Cuddles')

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

empalme sin comillas
empalme sin comillas fuerza la evaluación de un símbolo dentro de una forma de cuasicuotas, al igual que
unquote. empalme sin comillas sólo se puede utilizar cuando el símbolo sin comillas contiene un
valor iterable, ya que "empalma" ese iterable en la forma de cuasicuotas. empalme sin comillas is
alias al ~@ símbolo.

(por defecto números [1 2 3 4])
(cuasiquote (+ (números de empalme sin comillas)))
; => (u '+' 1L 2L 3L 4L)

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

cuando
cuando es parecido a a menos que, excepto que prueba cuando el condicional dado es ¿Editas con tu equipo de forma remota?. No lo es
posible tener un más bloque en un cuando macro. A continuación se muestra la expansión de la
macro.

(cuando declaración condicional)

(si es condicional (do declaración))

mientras
mientras se utiliza para ejecutar uno o más bloques siempre que se cumpla una condición. La siguiente
El ejemplo dará como resultado "¡Hola mundo!" a la pantalla indefinidamente:

(mientras que True (imprime "¡Hola mundo!"))


se utiliza para envolver la ejecución de un bloque dentro de un administrador de contexto. El contexto
El administrador puede configurar el sistema local y desmontarlo de forma controlada. El
ejemplo arquetípico de uso es al procesar archivos. puede vincular el contexto a un
argumento o ignórelo por completo, como se muestra a continuación:

(con bloque [[arg (expr)]])

(con bloque [[(expr)]])

(con bloque [[arg (expr)] [(expr)]])

El siguiente ejemplo abrirá el NOTICIAS archivo e imprime su contenido en la pantalla. El
El archivo se cierra automáticamente una vez procesado.

(con [[f (abrir "NOTICIAS")]] (imprimir (.read f)))

con decorador
con decorador se usa para envolver una función con otra. La función que realiza el
La decoración debe aceptar un único valor: la función que se está decorando y devolver un nuevo
función. con decorador toma un mínimo de dos parámetros: la función que realiza
la decoración y la función que se está decorando. Se puede configurar más de una función de decorador.
aplicado; se aplicarán en orden de más externo a más interno, es decir. la primera
decorador será el más externo, y así sucesivamente. Los decoradores con argumentos se llaman simplemente
como una llamada de función.

(con decorador decorador divertido
(defn alguna función [] ...)

(con-decorador decorador1 decorador2 ...
(defn alguna función [] ...)

(con decorador (decorador arg) ..
(defn alguna función [] ...)

En el siguiente ejemplo, inc-decorador se usa para decorar la función adición con un
función que toma dos parámetros y llama a la función decorada con valores que son
incrementado en 1. Cuando el decorado adición se llama con los valores 1 y 1, el final
el resultado será 4 (1 + 1 + 1 + 1).

=> (defn inc-decorador [func]
... (fn [valor-1 valor-2] (func (+ valor-1 1) (+ valor-2 1))))
=> (defn inc2-decorator [func]
... (fn [valor-1 valor-2] (func (+ valor-1 2) (+ valor-2 2))))

=> (con-decorador inc-decorador (defn adición [ab] (+ ab)))
=> (suma 1 1)
4
=> (con-decorador inc2-decorador inc-decorador
... (defn suma [ab] (+ ab)))
=> (suma 1 1)
8

con gensyms
Nuevo en la versión 0.9.12.

con-gensym se utiliza para generar un conjunto de genio para usar en una macro. El siguiente código:

(con-gensyms [abc]
...)

se expande a:

(deje [[a (gensym)
[b (gensimo)
[c (gensim)]]
...)

VEA ADEMÁS:
Sección using-gensym

rendimiento
rendimiento se utiliza para crear un objeto generador que devuelve uno o más valores. El generador
es iterable y, por lo tanto, se puede utilizar en bucles, listas por comprensión y otros similares
construcciones

La función números al azar muestra cómo se pueden usar los generadores para generar series infinitas
sin consumir una cantidad infinita de memoria.

=> (defn multiplicar [coeficientes base]
... (para [[(, coeficiente base) (coeficientes de base zip)]]
... (rendimiento (* coeficiente base))))

=> (multiplicar (rango 5) (rango 5))


=> (lista-comp valor [valor (multiplicar (rango 10) (rango 10))])
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

=> (importación aleatoria)
=> (defn números aleatorios [bajo alto]
... (while True (rendimiento (.randint aleatorio bajo alto))))
=> (list-comp x [x (tome 15 (números aleatorios 1 50))])])
[7, 41, 6, 22, 32, 17, 5, 38, 18, 38, 17, 14, 23, 23, 19]

rendimiento de
Nuevo en la versión 0.9.13.

PYTHON 3.3 Y UP ¡SOLAMENTE!

rendimiento de se utiliza para llamar a un subgenerador. Esto es útil si desea que su corrutina
ser capaz de delegar sus procesos a otra corrutina, digamos, si usa algo elegante como
asíncio.

Hy Core
Core Clave
Butlast
Uso: (Butlast col)

Devuelve un iterador de todos menos el último elemento de Coll.

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

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

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

=> (importar herramientas de iteración)
=> (lista (toma 5 (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

col?
Nuevo en la versión 0.10.0.

Uso: (col? x)

Returns ¿Editas con tu equipo de forma remota? if x es iterable y no una cadena.

=> (coll? [1 2 3 4])
¿Editas con tu equipo de forma remota?

=> (coll? {"a" 1 "b" 2})
¿Editas con tu equipo de forma remota?

=> (coll? "abc")
Falso

cons
Nuevo en la versión 0.10.0.

Uso: (contras a b)

Devuelve una nueva celda de contras con coche. a y cdr b.

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

=> (= 'hd (coche a))
¿Editas con tu equipo de forma remota?

=> (= 'tl (cdr a))
¿Editas con tu equipo de forma remota?

idiotas?
Nuevo en la versión 0.10.0.

Uso: (¿contras? Foo)

Comprueba si foo es una celda de contras.

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

=> (contras? a)
¿Editas con tu equipo de forma remota?

=> (contras? nulo)
Falso

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

dic
Uso: (dic x)

Devuelve uno menos que x. Equivalente a (- x 1). Eleva Error de tecleado if (¿No estás registrado como (¿numérico? X)).

=> (3 de diciembre)
2

=> (0 de diciembre)
-1

=> (12.3 de diciembre)
11.3

desmontar
Nuevo en la versión 0.10.0.

Uso: (desmontar árbol &Opcional [codegen falso])

Volcar Python AST para Hy dado árbol a salida estándar. Si codificador is ¿Editas con tu equipo de forma remota?, la función
imprime código Python en su lugar.

=> (desensamblar '(imprimir "¡Hola mundo!"))
Módulo(
cuerpo = [
Expr (value = Call (func = Name (id = 'print'), args = [Str (s = 'Hello World!')], Keywords = [], starargs = None, kwargs = None))])

=> (desensamblar '(imprimir "¡Hola mundo!") verdadero)
print ('¡Hola mundo!')

¿vacío?
Uso: (¿vacío? col)

Returns ¿Editas con tu equipo de forma remota? if Coll esta vacio. Equivalente a (= 0 (solo col)).

=> (¿vacío? [])
¿Editas con tu equipo de forma remota?

=> (¿vacío? "")
¿Editas con tu equipo de forma remota?

=> (¿vacío? (, 1 2))
Falso

¿cada?
Nuevo en la versión 0.10.0.

Uso: (¿cada? pred col)

Returns ¿Editas con tu equipo de forma remota? if (antes x) es lógico cierto para cada x in Coll, De lo contrario Falso. Regreso ¿Editas con tu equipo de forma remota?
if Coll esta vacio.

=> (¿todos? ¿pares? [2 4 6])
¿Editas con tu equipo de forma remota?

=> (¿todos? ¿pares? [1 3 5])
Falso

=> (¿todos? ¿pares? [2 4 5])
Falso

=> (¿todos? ¿pares? [])
¿Editas con tu equipo de forma remota?

¿flotador?
Uso: (¿flotador? x)

Returns ¿Editas con tu equipo de forma remota? if x es un flotador.

=> (flotar? 3.2)
¿Editas con tu equipo de forma remota?

=> (flotar? -2)
Falso

¿incluso?
Uso: (¿incluso? x)

Returns ¿Editas con tu equipo de forma remota? if x incluso. Eleva Error de tecleado if (¿No estás registrado como (¿numérico? X)).

=> (par? 2)
¿Editas con tu equipo de forma remota?

=> (par? 13)
Falso

=> (par? 0)
¿Editas con tu equipo de forma remota?

identidad
Uso: (identidad x)

Devuelve el argumento proporcionado a la función.

=> (identidad 4)
4

=> (lista (identidad del mapa [1 2 3 4]))
[1 2 3 4]

Cª
Uso: (C ª x)

Devuelve uno más de x. Equivalente a (+ x 1). Eleva Error de tecleado if (¿No estás registrado como (¿numérico? X)).

=> (inc 3)
4

=> (inc 0)
1

=> (inc 12.3)
13.3

¿ejemplo?
Uso: (¿ejemplo? clase x)

Returns ¿Editas con tu equipo de forma remota? if x es una instancia de clase.

=> (instancia? float 1.0)
¿Editas con tu equipo de forma remota?

=> (instancia? int 7)
¿Editas con tu equipo de forma remota?

=> (instancia? str (str "foo"))
¿Editas con tu equipo de forma remota?

=> (defclass TestClass [objeto])
=> (setv inst (TestClass))
=> (instancia? TestClass inst)
¿Editas con tu equipo de forma remota?

¿entero?
Uso: (¿entero? x)

Returns ¿Editas con tu equipo de forma remota? if x es un entero. Para Python 2, esto es int or Corto. Para Python 3,
esto es int.

=> (entero? 3)
¿Editas con tu equipo de forma remota?

=> (entero? -2.4)
Falso

intercalar
Nuevo en la versión 0.10.1.

Uso: (intercalar sec1 sec2 ...)

Devuelve un iterable del primer elemento en cada una de las secuencias, luego el segundo, etc.

=> (lista (intercalar (rango 5) (rango 100)))
[0, 100, 1, 101, 2, 102, 3, 103, 4, 104]

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

interponer
Nuevo en la versión 0.10.1.

Uso: (interponer ít siguiente)

Devuelve un iterable de los elementos de la secuencia separados por el elemento.

=> (lista (interponer "!" "abcd"))
['a B C D']

=> (lista (interponer -1 (rango 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

iterable?
Uso: (iterable? x)

Returns ¿Editas con tu equipo de forma remota? if x es iterable. Los objetos iterables devuelven un nuevo iterador cuando (itero x) is
llamado. Contrastar con iterador?.

=> ;; funciona para cuerdas
=> (iterable? (str "abcde"))
¿Editas con tu equipo de forma remota?

=> ;; funciona para listas
=> (iterable? [1 2 3 4 5])
¿Editas con tu equipo de forma remota?

=> ;; funciona para tuplas
=> (iterable? (, 1 2 3))
¿Editas con tu equipo de forma remota?

=> ;; funciona para dictados
=> (iterable? {: a 1: b 2: c 3})
¿Editas con tu equipo de forma remota?

=> ;; funciona para iteradores / generadores
=> (iterable? (repetir 3))
¿Editas con tu equipo de forma remota?

iterador?
Uso: (iterador? x)

Returns ¿Editas con tu equipo de forma remota? if x es un iterador. Los iteradores son objetos que regresan a sí mismos como un
iterador cuando (itero x) se llama. Contrastar con iterable?.

=> ;; no funciona para una lista
=> (iterador? [1 2 3 4 5])
Falso

=> ;; pero podemos obtener un iter de la lista
=> (iterador? (iter [1 2 3 4 5]))
¿Editas con tu equipo de forma remota?

=> ;; no funciona para dict
=> (iterador? {: a 1: b 2: c 3})
Falso

=> ;; crea un iterador a partir del dict
=> (iterador? (iter {: a 1: b 2: c 3}))
¿Editas con tu equipo de forma remota?

lista*
Uso: (lista* cabeza &descansar cola)

Genera una cadena de celdas de contras anidadas (una lista de puntos) que contiene los argumentos. Si el
La lista de argumentos solo tiene un elemento, devuélvalo.

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

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

=> (lista * 1)
1

=> (contras? (lista * 1 2 3 4))
¿Editas con tu equipo de forma remota?

macroexpandir
Nuevo en la versión 0.10.0.

Uso: (macroexpandir formar)

Devuelve la expansión macro completa de formulario.

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

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

macroexpandir-1
Nuevo en la versión 0.10.0.

Uso: (macroexpandir-1 formar)

Devuelve la expansión macro de un solo paso de formulario.

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

fusionarse con
Nuevo en la versión 0.10.1.

Uso: (fusionarse con f &descansar mapas)

Devuelve un mapa que consta del resto de mapas unidos primero. Si ocurre una clave en
más de un mapa, los mapas de este último (de izquierda a derecha) se combinarán con
el mapeo en el resultado llamando (f val-en-resultado val-en-último).

=> (fusionar 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)

Returns ¿Editas con tu equipo de forma remota? if x es menor que cero. Eleva Error de tecleado if (¿No estás registrado como (¿numérico? X)).

=> (neg? -2)
¿Editas con tu equipo de forma remota?

=> (neg? 3)
Falso

=> (neg? 0)
Falso

nil
Uso: (¿nulo? x)

Returns ¿Editas con tu equipo de forma remota? if x is cero / Ninguna.

=> (nulo? nulo)
¿Editas con tu equipo de forma remota?

=> (nulo? Ninguno)
¿Editas con tu equipo de forma remota?

=> (cero? 0)
Falso

=> (setf x nil)
=> (nulo? x)
¿Editas con tu equipo de forma remota?

=> ;; list.append siempre devuelve None
=> (nulo? (.append [1 2 3] 4))
¿Editas con tu equipo de forma remota?

¿ninguno?
Uso: (¿ninguna? x)

Returns ¿Editas con tu equipo de forma remota? if x is Ninguna.

=> (¿ninguno? Ninguno)
¿Editas con tu equipo de forma remota?

=> (ninguno? 0)
Falso

=> (setf x Ninguno)
=> (¿ninguno? x)
¿Editas con tu equipo de forma remota?

=> ;; list.append siempre devuelve None
=> (¿ninguno? (.append [1 2 3] 4))
¿Editas con tu equipo de forma remota?

nth
Uso: (enésimo Coll n &Opcional [defecto nulo])

Devuelve el n-th elemento de una colección, contando desde 0. Devuelve el valor predeterminado, cero, Si
fuera de los límites (a menos que se especifique lo contrario). Eleva ValorError if n es negativo

=> (enésimo [1 2 4 7] 1)
2

=> (enésimo [1 2 4 7] 3)
7

=> (cero? (enésimo [1 2 4 7] 5))
¿Editas con tu equipo de forma remota?

=> (nth [1 2 4 7] 5 "predeterminado")
'Default'

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

=> (enésimo [1 2 4 7] -1)
Rastreo (llamadas recientes más última):
...
ValueError: los índices para islice () deben ser Ninguno o un número entero: 0 <= x <= sys.maxsize.

¿numérico?
Uso: (¿numérico? x)

Returns ¿Editas con tu equipo de forma remota? if x es un numérico, como se define en Python numeros Numero clase.

=> (numérico? -2)
¿Editas con tu equipo de forma remota?

=> (numérico? 3.2)
¿Editas con tu equipo de forma remota?

=> (numérico? "foo")
Falso

¿extraño?
Uso: (¿impar? x)

Returns ¿Editas con tu equipo de forma remota? if x es impar. Eleva Error de tecleado if (¿No estás registrado como (¿numérico? X)).

=> (¿impar? 13)
¿Editas con tu equipo de forma remota?

=> (¿impar? 2)
Falso

=> (¿impar? 0)
Falso

pos?
Uso: (pos? x)

Returns ¿Editas con tu equipo de forma remota? if x es mayor que cero. Eleva Error de tecleado if (¿No estás registrado como (¿numérico? X)).

=> (pos? 3)
¿Editas con tu equipo de forma remota?

=> (pos? -2)
Falso

=> (pos? 0)
Falso

segundo
Uso: (segundo col)

Devuelve el segundo miembro de Coll. Equivalente a (obtener Coll 1).

=> (segundo [0 1 2])
1

algo
Nuevo en la versión 0.10.0.

Uso: (algunos pred col)

Devuelve el primer valor lógicamente verdadero de (antes x) para cualquier x in Coll, De lo contrario cero.
Ida y vuelta cero if Coll esta vacio.

=> (algunos incluso? [2 4 6])
¿Editas con tu equipo de forma remota?

=> (nulo? (algunos pares? [1 3 5]))
¿Editas con tu equipo de forma remota?

=> (nulo? (alguna identidad [0 "" []]))
¿Editas con tu equipo de forma remota?

=> (algo de identidad [0 "cadena no vacía" []])
'cadena no vacía'

=> (nulo? (algunos incluso? []))
¿Editas con tu equipo de forma remota?

¿cuerda?
Uso: (¿cuerda? x)

Returns ¿Editas con tu equipo de forma remota? if x es una cuerda.

=> (cadena? "foo")
¿Editas con tu equipo de forma remota?

=> (cadena? -2)
Falso

¿símbolo?
Uso: (¿símbolo? x)

Returns ¿Editas con tu equipo de forma remota? if x es un símbolo.

=> (símbolo? 'foo)
¿Editas con tu equipo de forma remota?

=> (símbolo? '[abc])
Falso

¿cero?
Uso: (¿cero? x)

Returns ¿Editas con tu equipo de forma remota? if x Es cero.

=> (cero? 3)
Falso

=> (cero? -2)
Falso

=> (cero? 0)
¿Editas con tu equipo de forma remota?

Secuencia Clave
Las funciones de secuencia pueden crear u operar en una secuencia potencialmente infinita sin
requiriendo que la secuencia se realice completamente en una lista o contenedor similar. Hacen esto por
devolviendo un iterador de Python.

Podemos usar el generador canónico de números infinitos de Fibonacci como ejemplo de cómo usar
algunas de estas funciones.

(definición fib []
(establecido en 0)
(establecimiento b 1)
(aunque cierto
(rendimiento a)
(setv (, ab) (, b (+ ab)))))

Nota la (mientras verdadero ...) círculo. Si ejecutamos esto en el REPL,

=> (fib)


Llamar a la función solo devuelve un iterador, pero no funciona hasta que lo consumimos.
No se recomienda probar algo como esto, ya que el bucle infinito se ejecutará hasta que
consume toda la RAM disponible, o en este caso hasta que lo maté.

=> (lista (fib))
[1] 91474 muertos por

Para obtener los primeros 10 números de Fibonacci, use tomar. Tenga en cuenta que tomar también devuelve un generador,
así que creo una lista a partir de él.

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

Para obtener el número de Fibonacci en el índice 9, (comenzando desde 0):

=> (nth (fib) 9)
34

Cycle
Uso: (ciclo col)

Devuelve un iterador infinito de los miembros de coll.

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

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

distinto
Uso: (distinto col)

Devuelve un iterador que contiene solo los miembros únicos en Coll.

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

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

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

caer
Uso: (soltar n col)

Devuelve un iterador, omitiendo el primero. n miembros de Coll. Eleva ValorError if n is
negativo.

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

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

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

=> (lista (soltar 6 [1 2 3 4 5]))
[]

última gota
Uso: (caer al final n col)

Devuelve un iterador de todos menos el último n artículos en Coll. Eleva ValorError if n is
negativo.

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

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

=> (lista (drop-last 100 (rango 100)))
[]

=> (importar herramientas de iteración)
=> (lista (toma 5 (elimina los últimos 100 (itertools.count 10))))
[10, 11, 12, 13, 14]

gota-mientras
Uso: (soltar mientras pred col)

Devuelve un iterador, omitiendo miembros de Coll hasta pred is Falso.

=> (lista (eliminar-mientras que par? [2 4 7 8 9]))
[7, 8, 9]

=> (lista (drop-while numérico? [1 2 3 Ninguno "a"])))
[Ninguno, u'a ']

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

filtrar
Uso: (filtrar pred col)

Devuelve un iterador para todos los elementos de Coll que pasan el predicado pred.

Vea también remove.

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

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

aplanar
Nuevo en la versión 0.9.12.

Uso: (aplanar col)

Devuelve una única lista de todos los elementos de Coll, acoplando todas las listas contenidas y / o
tuplas.

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

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

iterar
Uso: (iterar fn x)

Devuelve un iterador de x, fn (x), fn (fn (x)), etc.

=> (lista (toma 5 (itera inc 5)))
[5, 6, 7, 8, 9]

=> (lista (toma 5 (iterar (fn [x] (* xx)) 5)))
[5, 25, 625, 390625, 152587890625]

leer
Uso: (leer &Opcional [desde el archivo eof])

Lee la siguiente expresión Hy de desde el archivo (por defecto a sistema.stdin), y puede tomar un
byte único como EOF (por defecto es una cadena vacía). Eleva EOFError if desde el archivo termina antes
se puede analizar una expresión completa.

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

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

=>; asumiendo que "example.hy" contiene:
=>; (escribe "hola")
=>; (escriba "¡novios!")
=> (con [[f (open "example.hy")]]
... (tratar
... (aunque cierto
... (deje [[exp (leer f)]]
... (hacer
... (imprime "OHY" exp)
... (exp. de evaluación))))
... (captura [e EOFError]
... (imprime "EOF!"))))
OHY ('imprimir' 'hola')
¡Hola
OHY ('imprimir' '¡novios!')
novios!
¡EOF!

remove
Uso: (retirar pred col)

Devuelve un iterador de Coll con elementos que pasan el predicado, pred, eliminado.

Vea también filtrar.

=> (lista (¿eliminar impares? [1 2 3 4 5 6 7]))
[2, 4, 6]

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

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

repetir
Uso: (repetir x)

Devuelve un iterador (infinito) de x.

=> (lista (toma 6 (repite "s")))
[U's ', u's', u's ', u's', u's ', u's']

repetidamente
Uso: (repetidamente nota)

Devuelve un iterador llamando fn repetidamente.

=> (importar [aleatorio [randint]])

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

tomar
Uso: (llevar n col)

Devuelve un iterador que contiene el primero n miembros de Coll. Eleva ValorError if n is
negativo.

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

=> (lista (toma 4 (repite "s")))
[u's ', u's', u's ', u's']

=> (lista (toma 0 (repite "s")))
[]

toma enésima
Uso: (toma enésimo n col)

Devuelve un iterador que contiene cada n-th miembro de Coll.

=> (lista (toma enésimo 2 [1 2 3 4 5 6 7]))
[1, 3, 5, 7]

=> (lista (toma enésimo 3 [1 2 3 4 5 6 7]))
[1, 4, 7]

=> (lista (toma enésimo 4 [1 2 3 4 5 6 7]))
[1, 5]

=> (lista (toma enésimo 10 [1 2 3 4 5 6 7]))
[ 1 ]

tomar tiempo
Uso: (tómate un tiempo pred col)

Devuelve un iterador de Coll siempre que pred devoluciones ¿Editas con tu equipo de forma remota?.

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

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

=> (lista (tomar-mientras neg? [1 2 3 -4 5]))
[]

zipcon
Nuevo en la versión 0.9.13.

Uso: (cremallera con fn Coll ...)

Equivalente a Código Postal, pero usa una función de múltiples argumentos en lugar de crear una tupla. Si
zipcon se llama con N colecciones, entonces fn debe aceptar N argumentos.

=> (operador de importación)
=> (lista (zipwith operator.add [1 2 3] [4 5 6]))
[5, 7, 9]

Testimoniales Macros
Las macros de lector le dan a Lisp el poder de modificar y alterar la sintaxis sobre la marcha. Tu no quieres
Notación polaca? Una macro de lector puede hacer precisamente eso. ¿Quieres la forma de Clojure de tener un
regex? Las macros de lector también pueden hacer esto fácilmente.

Sintaxis
=> (defreader ^ [expr] (print expr))
=> # ^ (1 2 3 4)
(1 2 3 4)
=> # ^ "Hola"
"Hola"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

Hy no tiene literal para tuplas. Digamos que no te gusta (, ...) y quiero algo más. Esta
es un lector de problemas que las macros pueden resolver de manera ordenada.

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

¡Incluso podrías hacerlo como Clojure y tener un literal para expresiones regulares!

=> (importar re)
=> (defreader r [expr] `(re.compile ~ expr))
=> #r ". *"
<_sre.SRE_Pattern objeto en 0xcv7713ph15 #>

Implementación
defraudador toma un solo carácter como nombre de símbolo para la macro del lector; algo más
devolverá un error. En cuanto a la implementación, defraudador se expande en una lambda cubierta con un
decorador. Este decorador guarda la lambda en un diccionario con su nombre de módulo y
símbolo.

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

# se expande en (dispatch_reader_macro ...) donde el símbolo y la expresión se pasan a
la función correcta.

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

ADVERTENCIA:
Debido a una limitación en el lexer y parser de Hy, las macros del lector no pueden redefinir definidas
sintaxis tal como () [] {}. Es muy probable que esto se solucione en el futuro.

Interno Hy Documentación
NOTA:
Estos bits son principalmente útiles para las personas que piratean el propio Hy, pero también se pueden usar para
aquellos que profundizan en la programación macro.

Hy fexibles
Introducción a Hy fexibles
Los modelos Hy son una capa muy fina encima de los objetos Python regulares, que representan la fuente Hy
codificar como datos. Los modelos solo agregan información sobre la posición de la fuente y algunos métodos para
admite la manipulación limpia del código fuente de Hy, por ejemplo, en macros. Para lograr eso
objetivo, los modelos Hy son combinaciones de una clase base de Python y HyObjeto.

HyObjeto
hy.models.HyObjeto es la clase base de los modelos Hy. Solo implementa un método, reemplazar,
que reemplaza la posición de origen del objeto actual con la pasada como argumento.
Esto nos permite realizar un seguimiento de la posición original de las expresiones que son modificadas por
macros, ya sea en el compilador o en hy macros puras.

HyObjeto no está diseñado para usarse directamente para crear instancias de modelos Hy, sino solo como una mezcla
para otras clases.

Compuesto fexibles
El analizador Hy analiza las listas entre paréntesis y entre corchetes como modelos compuestos.

Lista Hy
hy.modelos.list.HyList es la clase base de los modelos Hy "iterables". Su uso básico es
representar entre corchetes [] listas, que, cuando se utilizan como expresión de nivel superior, se traducen a
Python enumera literales en la fase de compilación.

Agregar una HyList a otro objeto iterable reutiliza la clase del objeto del lado izquierdo,
un comportamiento útil cuando desea concatenar objetos Hy en una macro, por ejemplo.

HyExpresión
hy.modelos.expresión.HyExpresión hereda Lista Hy para entre paréntesis () Expresiones los
El resultado de la compilación de esas expresiones depende del primer elemento de la lista: el
El compilador distribuye expresiones entre formularios especiales del compilador, macros definidas por el usuario y
llamadas regulares a funciones de Python.

HyDict
hy.modelos.dict.HyDict hereda Lista Hy para corchetes {} expresiones, que compilan
hasta un literal de diccionario de Python.

La decisión de usar una lista en lugar de un dictado como clase base para HyDict permite más fácil
manipulación de dictados en macros, con el beneficio adicional de permitir expresiones compuestas
como claves de dictado (como, por ejemplo, el HyExpresión La clase de Python no se puede codificar con hash).

Atómico fexibles
En el flujo de entrada, cadenas entre comillas dobles, respetando la notación de Python para cadenas,
se analizan como un solo token, que se analiza directamente como un HiString.

Una cadena de caracteres ininterrumpida, que no incluye espacios, corchetes, comillas ni comillas dobles.
y comentarios, se analiza como un identificador.

Los identificadores se resuelven en modelos atómicos durante la fase de análisis en el siguiente orden:

· HyInteger

· HyFloat

· HyComplex (si el átomo no es un desnudo j)

· HyPalabra clave (si el átomo comienza con :)

· HySímbolo

HiString
hy.models.string.HyString es la clase base de modelos Hy equivalentes a cadenas. También
representa literales de cadena entre comillas dobles, "", que se compila en una cadena Unicode
literales en Python. cuerdas hy heredar objetos Unicode en Python 2 y objetos de cadena en
Python 3 (y, por lo tanto, no dependen de la codificación).

HiString los modelos basados ​​son inmutables.

Las cadenas literales Hy pueden abarcar varias líneas y el analizador las considera como una sola
unidad, respetando los escapes de Python para cadenas Unicode.

Numérico fexibles
hy.modelos.integer.HyInteger representa literales enteros (usando el Corto escriba en Python 2,
y int en Python 3).

hy.modelos.float.HyFloat representa literales de punto flotante.

hy.models.complex.HyComplex representa literales complejos.

Los modelos numéricos se analizan utilizando la rutina de Python correspondiente y Python numérico válido
los literales se convertirán en su contraparte Hy.

HySímbolo
hy.modelos.symbol.HySymbol es el modelo utilizado para representar símbolos en el lenguaje Hy. Eso
hereda HiString.

HySímbolo los objetos se alteran en la fase de análisis, para ayudar a la interoperabilidad de Python:

· Símbolos rodeados de asteriscos (*) se convierten en mayúsculas;

· Guiones (-) se convierten en guiones bajos (_);

· Un signo de interrogación al final (?) se convierte en un líder es_.

Advertencia: dado que la alteración se realiza durante la fase de análisis, es posible
Genere mediante programación HySymbols que no se pueden generar con el código fuente de Hy. Tal
El mecanismo es utilizado por gensym para generar símbolos "no internados".

HyPalabra clave
hy.modelos.palabra clave.HyPalabra Clave representa palabras clave en Hy. Las palabras clave son símbolos que comienzan con
a :. La clase hereda HiString.

Distinguir HyPalabras clave en HySímbolos, sin posibilidad de (involuntario)
choques, el carácter Unicode de uso privado "\ uFDD0" se antepone a la palabra clave literal
antes del almacenamiento.

Desventajas Células
hy.modelos.cons.HyCons es una representación de Python-friendly cons células. Las celdas de los contras son
especialmente útil para imitar características de variantes de LISP "habituales" como Scheme o Common
Ceceo.

Una celda de contras es un objeto de 2 elementos, que contiene un de (cabeza) y un cdr (cola). En algunos Lisp
variantes, la celda de contras es el bloque de construcción fundamental, y las expresiones-S son en realidad
representado como listas enlazadas de celdas de contras. Este no es el caso en Hy, como es habitual
Las expresiones están hechas de listas de Python envueltas en un HyExpresión. Sin embargo, las HyCons
imita el comportamiento de las variantes de Lisp "habituales" así:

· (contras algo nulo) is (HyExpresión [algo])

· (contras algo alguna lista) is ((escribe alguna lista) (+ [algo] alguna-lista)) (Si
alguna-lista hereda de lista).

· (obtener (contras a b) 0) is a

· (rodaja (contras a b) 1) is b

Hy admite una sintaxis de lista de puntos, donde '(a . b) significa (contras 'a 'B) y '(a b . c) significa
(contras 'a (contras 'b 'C)). Si el compilador encuentra una celda de contras en el nivel superior, genera
un error de compilación.

HyCons envuelve los argumentos pasados ​​(car y cdr) en tipos Hy, para facilitar la manipulación de
contras células en un contexto macro.

Hy Interno TEORÍA
General
Los componentes internos de Hy funcionan actuando como una interfaz para el código de bytes de Python, de modo que Hy mismo
se compila en Python Bytecode, lo que permite que un tiempo de ejecución de Python sin modificar ejecute código Hy,
sin siquiera darme cuenta.

La forma en que hacemos esto es traduciendo Hy en una estructura de datos interna de Python AST, y
construir ese AST en código de bytes de Python usando módulos del estándar de Python
biblioteca, para que no tengamos que duplicar todo el trabajo de los componentes internos de Python para cada
lanzamiento único de Python.

Hy trabaja en cuatro etapas. Las siguientes secciones cubrirán cada paso de Hy desde la fuente hasta
tiempo de ejecución.

pasos 1 y 2: Tokenización y Parsing
La primera etapa de la compilación de Hy es convertir la fuente en tokens con los que podamos lidiar. Nosotros
use un proyecto llamado rply, que es un analizador muy agradable (y rápido), escrito en un subconjunto
de Python llamado rpython.

El código de lexing está todo definido en hy.lex.lexer. Este código en su mayoría solo define el Hy
gramática, y todas las partes duras reales son atendidas por rply - simplemente definimos
"devoluciones de llamada" para responder en hy.lex.parser, que toma los tokens generados y devuelve el
Modelos Hy.

Puede pensar en los modelos Hy como el "AST" para Hy, es en lo que operan las Macros
(directamente), y es lo que usa el compilador cuando compila Hy hacia abajo.

VEA ADEMÁS:
Sección Hy fexibles para obtener más información sobre los modelos Hy y lo que significan.

paso 3: Hy Compilación a Python AST
Aquí es donde ocurre la mayor parte de la magia en Hy. Aquí es donde tomamos Hy AST (los modelos),
y compílelos en Python AST. Aquí suceden un par de cosas raras que van más allá de algunas
problemas en AST, y trabajar en el compilador es uno de los trabajos más importantes que hacemos
tener.

El compilador es un poco complejo, así que no se sienta mal si no lo asimila en la primera toma,
puede llevar un poco de tiempo hacerlo bien.

El principal punto de entrada al compilador es HyASTCompiler.compilar. Se invoca este método y
el único método "público" real en la clase (es decir, realmente no prometemos el
API más allá de ese método).

De hecho, incluso internamente, no recurrimos directamente casi nunca, casi siempre forzamos
el árbol Hy a través compilar, y lo hará a menudo con subelementos de una expresión
eso tenemos. Depende del despachador basado en tipo enviar correctamente los subelementos.

Todos los métodos que preforman una compilación están marcados con la @builds () decorador. Usted puede
o pase la clase del modelo Hy que compila, o puede usar una cadena para
Expresiones Aclararé esto en un segundo.

Nombre Etapa Tipo de envío
Empecemos en el compilar método. Lo primero que hacemos es comprobar el tipo de cosa.
estamos construyendo. Miramos hacia arriba para ver si tenemos un método que pueda construir el tipo() que nos
tener y enviar al método que pueda manejarlo. Si no tenemos ningún método que pueda
construimos ese tipo, creamos un interno Excepción.

Por ejemplo, si tenemos un HiString, tenemos una asignación casi 1 a 1 de Hy AST a Python
AST. El compilar_cadena el método toma el HiStringy devuelve un ast.Str ()
poblado con los números de línea y el contenido correctos.

Macro-Expandir
Si obtenemos un HyExpresión, intentaremos ver si se trata de una macro conocida y presionaremos para tener
se expandió invocando hy.macros.macroexpandir, luego vuelva a colocar el resultado en
HyASTCompiler.compilar.

Segundo Etapa Envío de expresión
El único caso especial es el HyExpresión, ya que necesitamos crear diferentes AST dependiendo
en el formulario especial en cuestión. Por ejemplo, cuando golpeamos un (Si verdadero verdadero falso), Que
Necesito generar un ast. siy compile correctamente los subnodos. Aquí es donde el @builds ()
con una cadena como argumento.

Para el expresión_compilada (que se define con un @builds (HyExpression)) enviará
basado en la cadena del primer argumento. Si, por alguna razón, el primer argumento no es
una cuerda, también manejará adecuadamente ese caso (muy probablemente levantando un Excepción).

Si Hy no conoce la cadena, se creará de forma predeterminada una ast. llamar, que intentará
hacer una llamada en tiempo de ejecución (en Python, algo como foo ()).

Temas Golpear Python AST
Python AST es genial; es lo que nos ha permitido escribir un proyecto tan poderoso sobre
Python sin tener que luchar demasiado contra Python. Como todo, hemos tenido nuestra parte justa de
problemas, y aquí hay una breve lista de los más comunes con los que puede encontrarse.

Python diferencia entre Declaraciones y Expresiones.

Esto puede no parecer un gran problema; de hecho, para la mayoría de los programadores de Python, esto
pronto se convierta en un momento de "Bueno, sí".

En Python, hacer algo como:

Imprimir para x in distancia(10): pass, porque Imprimir imprime expresiones, y para no es un
expresión, es una declaración de flujo de control. Cosas como 1 + 1 son Expresiones, como es lambda
x: 1 + x, pero otras características del idioma, como if, parao mientras son declaraciones.

Dado que no tienen "valor" para Python, esto hace que trabajar en Hy sea difícil, ya que hacer algo
como (impresión (Si verdadero verdadero falso)) no solo es común, se espera.

Como resultado, modificamos automáticamente las cosas usando un Resultado objeto, donde ofrecemos cualquier ast.stmt
que necesitan correr, y una sola ast.expr que se puede utilizar para obtener el valor de cualquier
se acaba de ejecutar. Hy hace esto forzando la asignación de cosas mientras corre.

Como ejemplo, el Hy:

(imprimir (si es verdadero verdadero falso))

Se convertirá en:

si es verdad:
_mangled_name_here = Verdadero
más:
_mangled_name_here = Falso

imprimir _mangled_name_here

Bien, eso fue un poco mentira, ya que en realidad convertimos esa declaración en:

imprimir Verdadero si es Verdadero en caso contrario Falso

Forzando las cosas en un ast.expr si podemos, pero la idea general se mantiene.

paso 4: Python Bytecode Salida y Runtime
Una vez que tengamos un árbol AST de Python que esté completo, podemos intentar compilarlo en Python
bytecode empujándolo a través de eval. De ahora en adelante, ya no tenemos el control y
Python se ocupa de todo. Esta es la razón por la que cosas como los rastreos de Python, pdb y
las aplicaciones de django funcionan.

Hy Macros
Usar genio para Más seguro Macros
Al escribir macros, se debe tener cuidado de evitar capturar variables externas o usar
nombres de variables que pueden entrar en conflicto con el código de usuario.

Usaremos una macro de ejemplo nif (consulta:
http://letoverlambda.com/index.cl/guest/chap3.html# seg_5 para una descripción más completa.)
nif es un ejemplo, algo así como un numérico if, donde según la expresión, uno de los
Se llama a 3 formas dependiendo de si la expresión es positiva, cero o negativa.

Un primer pase podría ser algo como:

(defmacro nif [expr forma pos forma cero forma neg]
`(deje [[nombre-oscuro ~ expr]]
(cond [(pos? nombre-oscuro) ~ forma-pos]
[(cero? nombre-oscuro) ~ forma-cero]
[(neg? nombre-oscuro) ~ forma-neg])))

donde nombre oscuro es un intento de elegir un nombre de variable para no entrar en conflicto con otras
código. Pero, por supuesto, aunque sea bien intencionado, esto no es garantía.

El método gensym está diseñado para generar un símbolo nuevo y único para tal ocasión.
Una versión mucho mejor de nif sería:

(defmacro nif [expr forma pos forma cero forma neg]
(deja [[g (gensym)]]
`(deje [[~ g ~ expr]]
(cond [(pos? ~ g) ~ pos-forma]
[(cero? ~ g) ~ forma cero]
[(neg? ~ g) ~ neg-forma]))))

Este es un caso fácil, ya que solo hay un símbolo. Pero si se necesitan varios
gensym's hay una segunda macro con gensyms que básicamente se expande a una serie de dejar
declaraciones:

(con-gensyms [abc]
...)

se expande a:

(deje [[a (gensym)
[b (gensimo)
[c (gensim)]]
...)

así que nuestro reescrito nif se vería así:

(defmacro nif [expr forma pos forma cero forma neg]
(con-gensyms [g]
`(deje [[~ g ~ expr]]
(cond [(pos? ~ g) ~ pos-forma]
[(cero? ~ g) ~ forma cero]
[(neg? ~ g) ~ neg-forma]))))

Finalmente, aunque podemos hacer una nueva macro que haga todo esto por nosotros. defmacro / g! tomará
todos los símbolos que comienzan con g! y llamar automáticamente genio con el resto del
símbolo. Entonces Georgia se convertiría (gensimo "a").

Nuestra versión final de nif, construido con defmacro / g! se convierte en:

(defmacro / g! nif [expr pos-forma cero-forma neg-forma]
`(deje [[~ g! res ~ expr]]
(cond [(pos? ~ g! res) ~ pos-forma]
[(¿cero? ~ g! res) ~ forma cero]
[(neg? ~ g! res) ~ neg-forma]))))

Cuentas de cheques Macro Argumentos y El aumento de Excepciones
Hy Compilador Construidos

CONTRIBUYENTE MÓDULOS ÍNDICE

Contenido:

Anafórico Macros
Nuevo en la versión 0.9.12.

El módulo de macros anafóricas hace que la programación funcional en Hy sea muy concisa y fácil de
leer.
Una macro anafórica es un tipo de macro de programación que captura deliberadamente alguna forma
suministrada a la macro que puede ser referida por una anáfora (una expresión que
a otro). - Wikipedia (http://en.wikipedia.org/wiki/Anaphoric_macro)

Macros
ap-si
Uso: (ap-si (fú) (impresión eso))

Evalúa la primera forma para determinar su veracidad y la vincula a it tanto en lo verdadero como en lo falso
.

un melocotón
Uso: (un melocotón [1 2 3 4 5] (impresión eso))

Evalúe el formulario de cada elemento de la lista para ver los efectos secundarios.

ap-cada-mientras
Uso: (ap-cada-mientras lista pred cuerpo)

Evaluar la forma para cada elemento donde devuelve la forma del predicado ¿Editas con tu equipo de forma remota?.

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

ap-mapa
Uso: (ap-mapa formulario lista)

La forma anafórica del mapa funciona como un mapa normal, excepto que en lugar de una función
objeto toma una forma Hy. El nombre especial it está vinculado al objeto actual desde el
lista en la iteración.

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

ap-mapa-cuando
Uso: (ap-mapa-cuando predfn reps lista)

Evaluar un mapeo sobre la lista usando una función de predicado para determinar cuándo aplicar la
.

=> (lista (ap-map-when impar? (* it 2) [1 2 3 4]))
[2, 2, 6, 4]

=> (lista (ap-map-when even? (* it 2) [1 2 3 4]))
[1, 4, 3, 8]

ap-filtro
Uso: (filtro ap formulario lista)

Al igual que con ap-mapa tomamos una forma especial en lugar de una función para filtrar los elementos del
lista. El nombre especial it está vinculado al elemento actual en la iteración.

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

ap-rechazar
Uso: (ap-rechazar formulario lista)

Esta función hace lo contrario de ap-filtro, rechaza los elementos que pasan
predicado. El nombre especial it está vinculado al elemento actual en la iteración.

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

ap-dotimes
Uso (ap-dotimes n cuerpo)

Esta función evalúa el cuerpo n veces, con la variable especial it obligado de 0 a
1-n. Es útil para efectos secundarios.

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

ap-primero
Uso (ap-primero predfn lista)

Esta función devuelve el primer elemento que pasa el predicado o Ninguna, Con el
variable especial it enlazado al elemento actual en iteración.

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

ap-último
Uso (ap-último predfn lista)

Esta función devuelve el último elemento que pasa el predicado o Ninguna, con el especial
variable it enlazado al elemento actual en iteración.

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

ap-reducir
Uso (ap-reducir formulario lista &Opcional valor inicial)

Esta función devuelve el resultado de aplicar la forma a los 2 primeros elementos del cuerpo y
aplicando el resultado y el tercer elemento, etc. hasta que se agote la lista. Opcionalmente un
se puede proporcionar el valor inicial para que la función se aplique al valor inicial y la
primer elemento en su lugar. Esto expone el elemento que se itera como it y el actual
valor acumulado como según.

=> (ap-reducir (+ it acc) (rango 10))
45

bucle / recurrir
Nuevo en la versión 0.10.0.

El loops / repetirse La macro ofrece a los programadores una forma sencilla de utilizar la optimización de llamadas finales (TCO)
en su código Hy.
Una llamada de cola es una llamada de subrutina que ocurre dentro de otro procedimiento como su final
acción; puede producir un valor de retorno que luego es devuelto inmediatamente por la llamada
procedimiento. Si alguna llamada que realiza una subrutina, tal que eventualmente pueda conducir
a esta misma subrutina que se llama nuevamente hacia abajo en la cadena de llamadas, está en la posición de cola,
se dice que tal subrutina es recursiva en cola, que es un caso especial de recursividad.
Las llamadas de cola son importantes porque se pueden implementar sin agregar una nueva pila
marco a la pila de llamadas. La mayor parte del marco del procedimiento actual no es necesario
más, y puede ser reemplazado por el marco de la llamada de cola. A continuación, el programa puede saltar
a la subrutina llamada. Producir dicho código en lugar de una secuencia de llamada estándar es
llamada eliminación de llamadas de cola u optimización de llamadas de cola. La eliminación de llamadas de cola permite
llamadas a procedimientos en posición de cola para ser implementadas tan eficientemente como declaraciones goto,
permitiendo así una programación estructurada eficiente. - Wikipedia (-
http://en.wikipedia.org/wiki/Tail_call)

Macros
loops
loops establece un punto de recursividad. Con loops, repetirse vuelve a enlazar las variables establecidas en el
punto de recursividad y envía la ejecución del código a ese punto de recursión. Si repetirse se utiliza en
una posición sin cola, se lanza una excepción.

Uso: (círculo Enlaces &descansar cuerpo)

Ejemplo:

(requiere hy.contrib.loop)

(defn factorial [n])
(bucle [[in] [acc 1]]
(si (cero? i)
según
(recurrir (dec i) (* acc i)))))

(factoriales 1000)

defmulti
Nuevo en la versión 0.10.0.

defmulti le permite sobrecargar una función por el número dado de argumentos y / o kwargs.
Inspirado en la versión de Clojure definir.

=> (requiere hy.contrib.multi)
=> (defmulti divertido
... ([a] "a")
... ([ab] "ab")
... ([abc] "abc"))
=> (divertido 1)
"Un"
=> (divertido 1 2)
"ab"
=> (divertido 1 2 3)
"a B C"

HACKING ON HY

Únete nuestros ¡Hyve!
¡Por favor, ven a piratear a Hy!

Por favor venga a pasar el rato con nosotros en #por que on irc.freenode.net!

Háblelo en Twitter con el #por que ¡hashtag!

¡Por favor bloguee sobre esto!

Por favor, no lo pintes en la cerca de tu vecino (sin pedirlo amablemente).

Hack!
Hacer esto:

1. Crear un virtual entorno:

$ virtualenvvenv

y activarlo:

PS venv / bin / activar

vea la sección envoltorio virtual para crear y gestionar su entorno virtual:

$ mkvirtualenv hy
$ trabajar en hy

2. Obtenga el código fuente:

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

o usa tu tenedor:

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

3. Instalar para piratería:

$ cd hy /
$ pip install -e.

4. Instale otros requisitos de desarrollo:

$ pip install -r requisitos-dev.txt

5. Haz cosas maravillosas; haz que alguien chille de alegría / disgusto por lo que has hecho.

Test!
Las pruebas se encuentran en pruebas /. Usamos nariz.

Para ejecutar las pruebas:

$ pruebas de nariz

Escribir pruebas --- ¡las pruebas son buenas!

Además, es bueno ejecutar las pruebas para todas las plataformas compatibles y para que cumplan con PEP 8
código. Puede hacerlo ejecutando tox:

$ tóxicos

¡Documento!
La documentación se encuentra en docs /. Usamos Esfinge.

Para compilar los documentos en HTML:

$ cd documentos
$ hacer html

Escribir documentos --- ¡los documentos son buenos! ¡Incluso este doc!

Contribuir
Las contribuciones son bienvenidas y muy apreciadas, cada poquito ayuda a hacer que Hy sea más
genialidad.

¡Las solicitudes de extracción son geniales! Nosotros los amamos; aquí hay una guía rápida:

· Bifurque el repositorio y cree una rama de tema para una función / corrección. Evite hacer cambios directamente
en la rama principal.

· Todas las funciones entrantes deben ir acompañadas de pruebas.

· Antes de enviar un PR, ejecute las pruebas y verifique su código con el estilo
guía. Puede hacer ambas cosas a la vez:

$ hacer d

· Convierta las confirmaciones en unidades lógicas, para que sea más fácil rastrearlas y navegar más tarde. Antes
enviar un PR, intente aplastar las confirmaciones en conjuntos de cambios a los que sea fácil volver
más tarde. Además, asegúrese de no dejar espacios en blanco falsos en los conjuntos de cambios; esta
evita la creación de confirmaciones de corrección de espacios en blanco más adelante.

· En lo que respecta a los mensajes de confirmación, intente adherirse a lo siguiente:

· Intente ceñirse al límite de 50 caracteres para la primera línea de los mensajes de confirmación de Git.

· Para más detalles / explicaciones, siga esto con una línea en blanco y continúe
describiendo el compromiso en detalle.

· Finalmente, agréguese al archivo AUTHORS (como una confirmación separada): se lo merece :)

· Todos los cambios entrantes deben ser controlados por 2 miembros diferentes del equipo central de Hylang.
La revisión adicional es claramente bienvenida, pero necesitamos un mínimo de 2 aprobaciones para cualquier
a través del cambio.

· Si un miembro principal envía un RP, busque 2 miembros principales que no incluyan el
Remitente de relaciones públicas. La idea aquí es que uno puede trabajar con el autor de relaciones públicas, y un segundo reconoce
todo el conjunto de cambios.

· Para documentación y otros cambios triviales, podemos fusionarnos después de un ACK. Tenemos
cobertura baja, por lo que sería genial mantener esa barrera baja.

Core Equipo
El equipo de desarrollo central de Hy consta de los siguientes desarrolladores:

· Julien Danjou

· Morten Linderud

· J Kenneth King

· Gergely Nagy

· Tuukka turco

· Karen oxidado

· Abhishek L

· Christopher Allan Webber

· Konrad Hinsen

· Testamento kahn-greene

· Paul Tagliamonte

· Nicolas dandrimont

· Chelín Tolbert

· Berker pekság

· Clinton N. Dreisbach

· él semaj

Use hy en línea usando los servicios de onworks.net