hy - Online na nuvem

PROGRAMA:

NOME

hy - hy Documentação [imagem: Hy] [imagem]

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

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

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

Lista hylang-discussão

IRC #oi no Freenode

Construa estado
Travis CI.UNINDENT

Hy é um dialeto maravilhoso de Lisp incorporado em Python.

Como Hy transforma seu código Lisp na árvore de sintaxe abstrata do Python, você tem
todo o belo mundo do Python ao seu alcance, em formato Lisp!

Conteúdo:

COMEÇO RÁPIDO

[imagem: Abraços de Karen Rustard] [imagem]

(Obrigado a Karen Rustad pelos abraços!)

COMO TO ENTRE HY REAIS RÁPIDO:

1. Crie um Virtual Python Meio Ambiente.

2. Ative seu ambiente virtual Python.

3. Instalar hy da PyPI com pip instalar hy.

4. Inicie um REPL com hy.

5. Digite coisas no REPL:

=> (imprima "Oi!")
Hy!
=> (defn saudaçõesnm [nome] (imprimir (+ "Hy" nome "!")))
=> (saudaçõesnm "SeuNome")
Olá, seu nome!

etc.

6. Pressione CTRL-D quando terminar.

AMD! Isso é surpreendente! I queremos para escrever a Hy .

7. Abra um editor de programação de elite e digite:

(print "Eu ia codificar na sintaxe Python, mas então peguei Hy.")

8. Salvar como incrível.hy.

9. E execute seu primeiro programa Hy:

oi incrível. oi

10.
Respire fundo para não hiperventilar.

11.
Sorria maliciosamente e fuja para o seu esconderijo e faça coisas indescritíveis.

TUTORIAL

Bem-vindo ao tutorial do Hy!

Resumindo, Hy é um dialeto Lisp, mas que converte sua estrutura em Python...
literalmente uma conversão na árvore de sintaxe abstrata do Python! (Ou, para ser mais grosseiro
termos, Hy é lisp-stick em Python!)

Isso é muito legal porque significa que Hy é várias coisas:

· Um Lisp que parece muito pitônico

· Para Lispers, uma ótima maneira de usar os poderes malucos do Lisp, mas no vasto mundo do Python
bibliotecas (sim, agora você pode escrever uma aplicação Django em Lisp!)

· Para Pythonistas, uma ótima maneira de começar a explorar Lisp, no conforto do Python!

· Para todos: uma linguagem agradável e com muitas ideias bacanas!

Basico introdução para Cicio para Pythonistas
Ok, talvez você nunca tenha usado Lisp antes, mas já usou Python!

Um programa “olá mundo” em Hy é realmente super simples. Vamos tentar:

(imprima "olá mundo")

Ver? Fácil! Como você deve ter adivinhado, é igual à versão Python de:

imprima "olá mundo"

Para somar algumas contas super simples, poderíamos fazer:

(+1)

O que retornaria 4 e seria equivalente a:

1 3 +

O que você notará é que o primeiro item da lista é a função que está sendo chamada e o
o resto dos argumentos são os argumentos que estão sendo passados. Na verdade, em Hy (como acontece com a maioria
Lisps), podemos passar vários argumentos para o operador plus:

(+1 3 55)

O que retornaria 59.

Talvez você já tenha ouvido falar de Lisp antes, mas não saiba muito sobre ele. Lisp não é tão difícil quanto você
você pode pensar, e Hy herda de Python, então Hy é uma ótima maneira de começar a aprender Lisp.
A principal coisa óbvia sobre Lisp é que há muitos parênteses. Isso pode
parece confuso no início, mas não é tão difícil. Vejamos alguns cálculos simples que são
envolto em um monte de parênteses que poderíamos inserir no interpretador Hy:

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

Isso retornaria 38. Mas por quê? Bem, poderíamos olhar para a expressão equivalente em
Pitão:

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

Se você tentasse descobrir como os itens acima funcionariam em python, é claro
descubra os resultados resolvendo cada parêntese interno. Essa é a mesma ideia básica em
Olá. Vamos tentar este exercício primeiro em Python:

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

Agora vamos tentar a mesma coisa em Hy:

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

Como você provavelmente adivinhou, esta última expressão com setv significa atribuir a variável
"resultado" para 38.

Ver? Não muito difícil!

Esta é a premissa básica do Lisp. Lisp significa "processamento de lista"; isso significa que o
a estrutura do programa é, na verdade, listas de listas. (Se você estiver familiarizado com Python
listas, imagine toda a mesma estrutura acima, mas com colchetes, qualquer
você poderá ver a estrutura acima como um programa e uma estrutura de dados.) Isto é
mais fácil de entender com mais exemplos, então vamos escrever um programa Python simples, testá-lo,
e então mostre o programa Hy equivalente:

def conversa_simples():
print "Olá! Gostaria de conhecer você. Conte-me sobre você!"
nome = raw_input("Qual é o seu nome?")
idade = raw_input("Qual é a sua idade?")
print "Olá " + nome + "! Vejo que você tem " + idade + " anos."

conversa_simples()

Se executássemos este programa, ele poderia ser assim:

Olá! Eu gostaria de conhecer você. Fale sobre você!
Qual o seu nome? Gary
Qual é a sua idade? 38
Olá Gary! Vejo que você tem 38 anos.

Agora vamos dar uma olhada no programa Hy equivalente:

(defn conversa simples []
(imprima "Olá! Gostaria de conhecer você. Conte-me sobre você!")
(nome setv (entrada bruta "Qual é o seu nome?"))
(setv idade (entrada bruta "Qual é a sua idade?"))
(print (+ "Olá" nome "! Vejo que você é"
idade " anos.")))

(conversa simples)

Se você observar o programa acima, desde que lembre que o primeiro elemento de cada
lista do programa é a função (ou macro... falaremos delas mais tarde) que está sendo chamada
e que o resto são argumentos, é muito fácil descobrir o que tudo isso significa.
(Como você provavelmente também adivinhou, definir é o método Hy de definição de métodos.)

Ainda assim, muitas pessoas acham isso confuso no início porque há muitos parênteses,
mas há muitas coisas que podem ajudar a tornar isso mais fácil: mantenha o recuo bonito e
use um editor com correspondência de parênteses (isso ajudará você a descobrir o que cada
parênteses emparelha com) e as coisas começarão a parecer confortáveis.

Existem algumas vantagens em ter uma estrutura de código que é, na verdade, um conjunto de dados muito simples.
estrutura na qual o núcleo do Lisp é baseado. Por um lado, significa que seus programas são
fácil de analisar e que toda a estrutura real do programa esteja claramente exposta
para você. (Há uma etapa extra em hy onde a estrutura que você vê é convertida para Python
próprias representações ... em Lisps "mais puros", como Common Lisp ou Emacs Lisp, os dados
estrutura que você vê no código e a estrutura de dados que é executada é muito mais
literalmente perto.)

Outra implicação disso são as macros: se a estrutura de um programa é um simples conjunto de dados
estrutura, isso significa que você pode escrever código que pode escrever código com muita facilidade, o que significa que
implementar recursos de linguagem totalmente novos pode ser muito rápido. Antes de Hy, isso não era
muito possível para programadores Python... agora você também pode fazer uso das incríveis macros
poder (apenas tome cuidado para não apontá-los para os pés)!

Hy is a Com sabor Lisp Python
Hy converte para a própria árvore de sintaxe abstrata do Python, então você logo começará a descobrir que tudo
o poder familiar do python está ao seu alcance.

Você tem acesso total aos tipos de dados e à biblioteca padrão do Python em Hy. Vamos experimentar
com isso no intérprete hy:

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

Se você estiver familiarizado com outros Lisps, pode estar interessado em saber que Hy suporta o Common
Método Lisp de cotação:

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

Você também tem acesso a todos os métodos legais dos tipos integrados:

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

O que é isso? Sim, de fato, isso é exatamente o mesmo que:

" fooooo ".strip()

Isso mesmo --- Lisp com notação de ponto! Se tivermos esta string atribuída como uma variável, nós
também pode fazer o seguinte:

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

E quanto aos condicionais?:

(se (tente alguma coisa)
(imprima "isto é se for verdade")
(imprima "isso é falso"))

Como você pode ver acima, o primeiro argumento para if é um teste de verdade, o segundo argumento é
o corpo se for verdadeiro, e o terceiro argumento (opcional!) for falso (ou seja, outro).

Se precisar fazer condicionais mais complexas, você descobrirá que não tem elif
disponível em Hy. Em vez disso, você deve usar algo chamado cond. Em Python, você pode fazer
algo como:

algumvar = 33
se algumvar > 50:
print "Essa variável é muito grande!"
elif somevar <10:
print "Essa variável é muito pequena!"
outro:
print "Essa variável está jussssst certa!"

Em Hy, você faria:

(condição
[(> algumvar 50)
(imprima "Essa variável é muito grande!")]
[(< algumvar 10)
(imprima "Essa variável é muito pequena!")]
[verdade
(imprima "Essa variável está jussssst certa!")])

O que você notará é que cond desliga entre uma instrução alguma que é executada e
verificado condicionalmente para verdadeiro ou falso e, em seguida, um pouco de código para executar se acontecer
parece ser verdade. Você também notará que o outro é implementado no final simplesmente por
Procurando por verdadeiro -- isso é porque verdadeiro sempre será verdade, então se chegarmos até aqui,
sempre execute esse!

Você pode notar isso acima se tiver um código como:

(se alguma condição
(corpo-se-verdadeiro)
(corpo-se-falso))

Mas espere! E se você quiser executar mais de uma instrução no corpo de um dos
esses?

Você pode fazer o seguinte:

(se (tente alguma coisa)
(Faz
(imprima "isto é se for verdade")
(print "e por que não, vamos continuar falando sobre como isso é verdade!))
(imprima "este ainda é simplesmente falso"))

Você pode ver que usamos do para agrupar várias instruções. Se você estiver familiarizado com outros
Lisps, isso é o equivalente a prognóstico outras posições.

Os comentários começam com ponto e vírgula:

(imprima "isso será executado")
; (imprima "mas isso não vai")
(+ 1 2 3); executaremos a adição, mas não este comentário!

O loop não é difícil, mas possui uma espécie de estrutura especial. Em Python, poderíamos fazer:

para eu em alcance(10)
print "'i' agora está em " + str(i)

O equivalente em Hy seria:

(para [i (intervalo 10)]
(print (+ "'i' agora está em " (str i))))

Você também pode importar e usar várias bibliotecas Python. Por exemplo:

(importar sistema operacional)

(se (os.path.isdir "/tmp/somedir")
(os.mkdir "/tmp/somedir/anotherdir")
(imprima "Ei, esse caminho não existe!"))

Gerenciadores de contexto do Python (com declarações) são usadas assim:

(com [[f (abrir "/tmp/data.in")]]
(imprimir (.ler f)))

que é equivalente a:

com open("/tmp/data.in") como f:
imprimir f.ler()

E sim, temos compreensões de lista! Em Python você pode fazer:

probabilidades_quadrado = [
pow(num, 2)
para num em alcance(100)
se num% 2 == 1]

Em Hy, você poderia fazer isso como:

(probabilidades setv ao quadrado
(lista-comp
(pou número 2)
(num (intervalo 100))
(= (% num 2) 1)))

; E, um exemplo roubado descaradamente de uma página do Clojure:
; Vamos listar todos os blocos de um tabuleiro de xadrez:

(lista-comp
(, xy)
(x (intervalo 8)
e "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 tem suporte para vários argumentos sofisticados e argumentos de palavras-chave. Em Python podemos
Vejo:

>>> def opcional_arg(pos1, pos2, palavra-chave1=Nenhum, palavra-chave2=42):
... retornar [pos1, pos2, palavra-chave1, palavra-chave2]
...
>>> opcional_arg(1, 2)
[1, 2, Nenhum, 42]
>>> opcional_arg(1, 2, 3, 4)
[1, 2, 3, 4]
>>> opcional_arg(palavra-chave1=1, pos2=2, pos1=3, palavra-chave2=4)
[3, 2, 1, 4]

A mesma coisa em Hy:

=> (defn opcional-arg [pos1 pos2 &palavra-chave opcional1 [palavra-chave2 42]]
... [pos1 pos2 palavra-chave1 palavra-chave2])
=> (opcional-arg 1 2)
[1 2 Nenhum 42]
=> (opcional-arg 1 2 3 4)
[1 2 3 4]

Se você estiver executando uma versão do Hy anterior a 0.10.1 (por exemplo, git master), também há um novo e interessante
sintaxe do argumento da palavra-chave:

=> (opcional-arg: palavra-chave1 1
... :pos2 2
... :pos1 3
...:palavra-chave2 4)
[3, 2, 1, 4]

Caso contrário, você sempre pode usar Aplique. Mas o que é Aplique?

Você está familiarizado com a passagem * args e ** kwargs em Python?:

>>> argumentos = [1 2]
>>> kwargs = {"palavra-chave2": 3
... "palavra-chave1": 4}
>>> opcional_arg(*args, **kwargs)

Podemos reproduzir isso com Aplique:

=> (argumentos setv [1 2])
=> (setv kwargs {"palavra-chave2" 3
... "palavra-chave1" 4})
=> (aplicar argumentos opcionais kwargs)
[1, 2, 4, 3]

Há também uma construção de argumentos de palavras-chave no estilo de dicionário que se parece com:

(defn outro estilo [&key {"key1" "val1" "key2" "val2"}]
[chave1 tecla2])

A diferença aqui é que, por se tratar de um dicionário, você não pode confiar em nenhum dicionário específico.
ordenando os argumentos.

Hy também apoia * args e ** kwargs. Em Python:

def alguma_func(foo, barra, *args, **kwargs):
importar impressão
pprint.pprint((foo,barra,args,kwargs))

O equivalente Hy:

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

Finalmente, é claro que precisamos de aulas! Em Python, poderíamos ter uma classe como:

classe FooBar (objeto):
"" "
Mais uma aula de exemplo
"" "
def __init__(self, x):
auto.x = x

def get_x(auto):
"" "
Devolva nossa cópia de x
"" "
retornar self.x

Em Hy:

(defclass FooBar [objeto]
"Mais uma aula de exemplo"
[[--iniciar--
(fn [próprio x]
(setv self.xx)
; Atualmente necessário para --init-- porque __init__ não precisa de nenhum
; Espero que isso passe :)
Nenhum)]

[obter-x
(fn [próprio]
"Devolva nossa cópia de x"
eu.x)]])

Você também pode fazer atributos em nível de classe. Em Python:

classe Cliente (modelos.Modelo):
nome = modelos.CharField(max_length=255)
endereço = modelos.TextField()
notas = modelos.TextField()

Em Hy:

(defclass Cliente [models.Model]
[[nome (models.CharField: comprimento máximo 255})]
[endereço (modelos.TextField)]
[notas (modelos.TextField)]])

Hy <-> Python interoperabilidade
Ao importar Hy, você pode usar Hy diretamente do Python!

Se você salvar o seguinte em saudações.hy:

(defn cumprimentar [nome] (imprimir "olá de hy," nome))

Então você pode usá-lo diretamente do python, importando hy antes de importar o módulo. Em
Pitão:

importar por
importar saudações

saudações.greet("Foo")

Você também pode declarar uma função em python (ou até mesmo uma classe!) e usá-la em Hy!

Se você salvar o seguinte em saudações.py em Python:

def saudar (nome):
print("olá, %s" % (nome))

Você pode usá-lo em Hy:

(importar saudações)
(.greet saudações "foo")

Para usar argumentos de palavras-chave, você pode usar em saudações.py:

def saudação(nome, título="Senhor"):
print("Saudações, %s %s" % (título,nome))

(importar saudações)
(.greet saudações "Foo")
(.greet saudações "Foo" "Darth")
(aplicar (. saudações, cumprimentar) ["Foo"] {"título" "Senhor"})

O que produziria:

Saudações, senhor Foo

Saudações, Darth Foo

Saudações, Senhor Foo

Dicas profissionais!
Hy também apresenta algo conhecido como "macro de threading", um recurso muito interessante do
Clojure. A "macro de threading" (escrita como ->) é usado para evitar aninhamento profundo de
expressões.

A macro de threading insere cada expressão no primeiro argumento da próxima expressão
lugar.

Vamos ao clássico:

(loop (imprimir (eval (ler))))

Em vez de escrever assim, podemos escrevê-lo da seguinte forma:

(-> (ler) (avaliar) (imprimir) (loop))

Agora, usando python-sh, podemos mostrar como a macro threading (devido à configuração do python-sh)
pode ser usado como um tubo:

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

O que, claro, se expande para:

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

Muito mais legível, não? Use a macro de segmentação!

HY ESTILO GUIA

"Sabe, Ministro, eu discordo de Dumbledore em muitos aspectos... mas você não pode negar que ele está
tenho estilo…” - Phineas Nigellus Black, Harry Oleiro e que o Encomenda of que o Phoenix

O guia de estilo Hy pretende ser um conjunto de regras básicas para o Hyve (sim, a comunidade Hy
orgulha-se de anexar Hy a tudo) para escrever código Hy idiomático. Hy deriva muito
do Clojure & Common Lisp, mantendo sempre a interoperabilidade do Python.

Prelúdio
A Tao of Hy
Ummon perguntou ao monge chefe: "Sobre qual sutra você está ensinando?"
"O Sutra do Nirvana."
“O Sutra do Nirvana tem as Quatro Virtudes, não é?”
"Tem."
Ummon perguntou, pegando uma xícara: “Quantas virtudes tem esta?”
“Nenhum”, disse o monge.
"Mas os povos antigos disseram que sim, não é?" disse Ummon.
"O que você acha do que eles disseram?"
Ummon bateu na xícara e perguntou: "Você entende?"
“Não”, disse o monge.
"Então", disse Ummon, "é melhor você continuar com suas palestras sobre o sutra."
- a macro (koan)

O que se segue ilustra uma breve lista de decisões de design que foram tomadas na elaboração de
Hy.

· Parece um Lisp; DTRT com ele (por exemplo, traços viram sublinhados, protetores de ouvido viram
tudo em maiúsculas).

· Ainda somos Python. A maioria dos internos é traduzida 1:1 para internos do Python.

· Use Unicode em qualquer lugar.

· Corrigir as más decisões no Python 2 quando pudermos (veja divisão_verdadeira).

· Em caso de dúvida, opte pelo Python.

· Se ainda não tiver certeza, opte pelo Clojure.

· Se você estiver ainda mais inseguro, opte pelo Common Lisp.

· Tenha em mente que não somos Clojure. Não somos Lisp comum. Somos Python Homoicônico, com
bits extras que fazem sentido.

traçado & entalhe
· Evite espaços à direita. Eles são péssimos!

· O recuo deverá ter 2 espaços (sem tabulações rígidas), exceto quando coincidir com o recuo de
a linha anterior.

;; Bom (e preferido)
(definição mentira [n]
(se (<= n 2)
n
(+ (mentira (- n 1)) (mentira (- n 2)))))

;; Ainda bem
(definição mentira [n]
(se (<= n 2) n (+ (mentira (- n 1)) (mentira (- n 2)))))

;; Ainda bem
(definição mentira [n]
(se (<= n 2)
n
(+ (mentira (- n 1)) (mentira (- n 2)))))

;; Histericamente ridículo
(definição mentira [n]
(se (<= n 2)
n;; sim, adoro apertar aleatoriamente a tecla de espaço
(+ (mentira (- n 1)) (mentira (- n 2)))))

· Os parênteses devem nunca ser deixados sozinhos, tristes e solitários em sua própria linhagem.

;; Bom (e preferido)
(definição mentira [n]
(se (<= n 2)
n
(+ (mentira (- n 1)) (mentira (- n 2)))))

;; Histericamente ridículo
(definição mentira [n]
(se (<= n 2)
n
(+ (mentira (- n 1)) (mentira (- n 2)))
)
) ; GAH, QUEIME COM FOGO

· Alinhar verticalmente deixar blocos.

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

· Os comentários in-line deverão estar a dois espaços do final do código; eles devem sempre ter um
espaço entre o caractere do comentário e o início do comentário. Além disso, tente não
comente o óbvio.

;; Bom
(setv ind (dec x)) ; a indexação começa em 0

;; Compatível com estilo, mas apenas afirma o óbvio
(setv ind (dec x)) ; define o índice para x-1

;; Ruim
(setv ind (dec x));digitando palavras para se divertir

Codificação Style
· Como convenção, tente não usar def para qualquer coisa que não seja variáveis ​​globais; usar setv
funções internas, loops, etc.

;; Bom (e preferido)
(def *limite* 400000)

(definições mentiras [ab]
(embora seja verdade
(rendimento a)
(setv (, ab) (, b (+ ab)))))

;; Ruim (e não preferido)
(definições mentiras [ab]
(embora seja verdade
(rendimento a)
(def (, ab) (, b (+ ab)))))

· Não use sintaxe de expressão s onde a sintaxe vetorial for pretendida. Por exemplo, o fato
que o primeiro desses dois exemplos funciona é apenas porque o compilador não é excessivamente
estrito. Na realidade, a sintaxe correta em locais como este é a última.

;; Ruim (e mal)
(defn foo (x) (imprimir x))
(foo 1)

;; Bom (e preferido)
(defn foo [x] (imprimir x))
(foo 1)

· Use a macro threading ou as macros threading tail ao encontrar linhas profundamente aninhadas
expressões s. No entanto, seja criterioso ao usá-los. Use-os quando a clareza e
a legibilidade melhora; não construa expressões complicadas e difíceis de entender.

;; Preferido
(def *nomes*
(com [f (abrir "nomes.txt")]
(-> (.read f) (.strip) (.replace "\"" "") (.split ",") (classificado))))

;; Não tão bom
(def *nomes*
(com [f (abrir "nomes.txt")]
(classificado (.split "," (.replace "\"" "" (.strip (.read f))))))))

;; Provavelmente não é uma boa ideia
(definir quadrado? [x]
(->> 2 (pow (int (sqrt x))) (= x)))

· A notação de ponto no estilo Clojure é preferida à chamada direta do método do objeto,
embora ambos continuem a ser suportados.

;; Bom
(com [fd (abrir "/ Etc / passwd")]
(imprimir (.readlines fd)))

;; Não tão bom
(com [fd (abrir "/ Etc / passwd")]
(imprimir (fd.readlines)))

Conclusão
“A moda desaparece, o estilo é eterno” – Yves Saint Laurent

Este guia é apenas um conjunto de diretrizes da comunidade e, obviamente, as diretrizes da comunidade não
não faz sentido sem uma comunidade ativa. Contribuições são bem-vindas. Junte-se a nós em #hy in
freenode, faça um blog sobre isso, tweet sobre isso e, o mais importante, divirta-se com Hy.

obrigado
· Este guia é fortemente inspirado em @paultag postagem do blog Hy Sobrevivência Guia

· O Clojure Style Guia

DOCUMENTAÇÃO ÍNDICE

Conteúdo:

Command Line Interface
hy
Command Line Opções
-c
Execute o código Hy em comando.

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

-i
Execute o código Hy em comando, então fique no REPL.

-m
Execute o código Hy em módulo, incluindo defmain se definido.

A -m flag encerra a lista de opções para que todos os argumentos após o módulo nome
são passados ​​para o módulo em sys.argv.

Novo na versão 0.10.2.

--espião Imprima o código Python equivalente antes de executar. Por exemplo:

=> (defn saudaçõesnm [nome] (imprimir (+ "Hy" nome "!")))
def saudaçõesnm(nome):
return print(((u'Hy ' + nome) + u'!'))
=> (saudaçõesnm "SeuNome")
saudaçõesnm(u'SeuNome')
Olá, seu nome!
=>

Novo na versão 0.9.11.

--show-tracebacks
Imprima tracebacks estendidos para exceções Hy.

Novo na versão 0.9.12.

-v Imprima o número da versão Hy e saia.

Hyc
Command Line Opções
arquivo[, arquivoN]
Compile o código Hy para bytecode Python. Por exemplo, salve o seguinte código como
hyname.hy:

(defn hy-hy [nome]
(imprimir (+ "Hy" nome "!")))

(oi-oi "Afroman")

Então corra:

$ hyc hyname.hy
$ python hyname.pyc
Olá, Afroman!

hy2py
Novo na versão 0.10.1.

Command Line Opções
-s

--com-fonte
Mostre a estrutura de origem analisada.

-a

--com-ast
Mostre o AST gerado.

-np

--sem-python
Não mostre o código Python gerado pelo AST.

Hy (O língua)
AVISO:
Isto está incompleto; considere contribuir para o esforço de documentação.

TEORIA of Hy
Hy mantém, acima de tudo, 100% de compatibilidade em ambas as direções com Python
em si. Todo o código Hy segue algumas regras simples. Memorize isso, pois vai entrar
calhar.

Essas regras ajudam a garantir que o código Hy seja idiomático e interligável em ambas as linguagens.

· Os símbolos em earmufs serão traduzidos para a versão maiúscula dessa string. Para
exemplo, Foo se tornará FOO.

· Entidades UTF-8 serão codificadas usando código puny e prefixado com oi_. Por exemplo, a ⚘
se tornará hy_w7h, ♥ se tornará hy_g6h e eu♥você se tornará hy_iu_t0x.

· Símbolos que contenham travessões serão substituídos por sublinhados. Por exemplo,
modelo de renderização se tornará render_template. Isto significa que os símbolos com traços
sombreie seus equivalentes de sublinhado e vice-versa.

Built-Ins
Hy apresenta vários formulários especiais que são usados ​​para ajudar a gerar Python AST correto.
A seguir estão os formulários "especiais", que podem ter um comportamento um pouco inesperado em
algumas situações.

.
Novo na versão 0.10.0.

. é usado para realizar acesso a atributos em objetos. Ele usa uma pequena DSL para permitir acesso rápido
acesso a atributos e itens em uma estrutura de dados aninhada.

Por exemplo, a

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

Compila até:

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

. compila seu primeiro argumento (no exemplo, Foo) como o objeto no qual fazer o
desreferência de atributo. Ele usa símbolos simples como atributos de acesso (no exemplo, Barra,
baz, babar) e compila o conteúdo das listas (no exemplo, [(+ 1 2)]) para indexação.
Outros argumentos geram um erro de compilação.

O acesso a atributos desconhecidos lança um Erro de atributo. O acesso a chaves desconhecidas lança um
Erro de índice (em listas e tuplas) ou um KeyError (em dicionários).

->
-> (Ou o segmentação macro) é usado para evitar o aninhamento de expressões. A macro de segmentação
insere cada expressão no primeiro lugar do argumento da próxima expressão. A seguir
código demonstra isso:

=> (defn saída [ab] (imprimir ab))
=> (-> (+ 4 6) (saída 5))
10 5

- >>
- >> (Ou o segmentação cauda macro) é semelhante ao segmentação macro, mas em vez de
inserindo cada expressão no primeiro argumento da próxima expressão, ele a anexa como o
último argumento. O código a seguir demonstra isso:

=> (defn saída [ab] (imprimir ab))
=> (->> (+ 4 6) (saída 5))
5 10

Aplique
Aplique é usado para aplicar uma lista opcional de argumentos e um dicionário opcional de kwargs
para uma função.

Uso: (Aplique nome-fn [arg] [kwargs])

Exemplos:

(defn thunk []
"olá")

(aplicar conversão)
;=> "olá"

(defn compra total [valor do preço e opcional [taxas 1.05] [IVA 1.1]]
(* preço valor taxas IVA))

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

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

(aplicar compra total [] {"preço" 10 "valor" 15 "IVA" 1.05})
;=> 165.375

e
e é usado em expressões lógicas. São necessários pelo menos dois parâmetros. Se todos os parâmetros
avaliar para Verdadeiro, o último parâmetro é retornado. Em qualquer outro caso, o primeiro valor falso
será retornado. Exemplo de uso:

=> (e Verdadeiro Falso)
Falso

=> (e Verdadeiro Verdadeiro)
Verdadeiro

=> (e Verdadeiro 1)
1

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

NOTA:
e entra em curto-circuito e para de avaliar os parâmetros assim que o primeiro falso é
encontrados.

=> (e False (imprima "olá"))
Falso

afirmar
afirmar é usado para verificar as condições enquanto o programa está em execução. Se a condição não for
conheci, um Erro de afirmação é gerado. afirmar pode levar um ou dois parâmetros. O primeiro
parâmetro é a condição a ser verificada e deve ser avaliada como Verdadeiro or Falso. O
segundo parâmetro, opcional, é um rótulo para o assert, e é a string que será
levantada com o Erro de afirmação. Por exemplo:

(afirmar (= valor esperado da variável))

(afirmar falso)
; Erro de afirmação

(afirmar (= 1 2) "um deve ser igual a dois")
; AssertionError: um deve ser igual a dois

Assoc
Assoc é usado para associar uma chave a um valor em um dicionário ou para definir um índice de uma lista
para um valor. São necessários pelo menos três parâmetros: o dados, estrutura a ser modificado, um chave
or índicee um valor. Se forem utilizados mais de três parâmetros, ele será associado em pares.

Exemplos de uso:

=>(deixe [[coleção {}]]
... (coleção associada "Cachorro" "Latido")
... (coleção impressa))
{u'Cão': u'Bark'}

=>(deixe [[coleção {}]]
... (coleção associada "Cachorro" "Latido" "Gato" "Miau")
... (coleção impressa))
{u'Gato': u'Miau', u'Cão': u'Bark'}

=>(deixe [[coleção [1 2 3 4]]]
... (coleção associada 2 Nenhum)
... (coleção impressa))
[1, 2, Nenhum, 4]

NOTA:
Assoc modifica a estrutura de dados no local e retorna nenhum.

quebrar
quebrar é usado para sair de um loop. Ele encerra o loop imediatamente. A seguir
exemplo tem um infinito enquanto loop que é finalizado assim que o usuário entra k.

(enquanto True (if (= "k" (entrada bruta "? "))
(quebrar)
(imprima "Tente novamente")))

cond
cond pode ser usado para construir aninhados if declarações. O exemplo a seguir mostra o
relação entre o macro e sua expansão:

(cond [condição-1 resultado-1]
[condição-2 resultado-2])

(se condição-1 resultado-1
(se condição-2 resultado-2))

Conforme mostrado abaixo, apenas o primeiro bloco de resultados correspondente é executado.

=> (defn valor de verificação [valor]
... (cond [(< valor 5) (imprimir "valor é menor que 5")]
... [(= valor 5) (imprimir "valor é igual a 5")]
... [(> valor 5) (imprimir "valor é maior que 5")]
... [Verdadeiro (imprimir "valor é algo que não deveria ser")]))

=> (valor de verificação 6)
o valor é maior que 5

continuar
continuar retorna a execução para o início de um loop. No exemplo a seguir,
(efeito colateral1) é chamado para cada iteração. (efeito colateral2), no entanto, só é chamado
todos os outros valores da lista.

;; assumindo que (efeito colateral1) e (efeito colateral2) são funções e
;; coleção é uma lista de valores numéricos

(para [x coleção]
(Faz
(efeito colateral1 x)
(se (% x 2)
(continuar))
(efeito colateral2 x)))

dict-comp
dict-comp é usado para criar dicionários. São necessários três ou quatro parâmetros. O primeiro
dois parâmetros são para controlar o valor de retorno (par chave-valor), enquanto o terceiro é
usado para selecionar itens de uma sequência. O quarto e opcional parâmetro pode ser usado para
filtre alguns dos itens da sequência com base em uma expressão condicional.

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

do / prognóstico
do e prognóstico são usados ​​para avaliar cada um de seus argumentos e retornar o último. Retornar
valores de todos os outros que não o último argumento são descartados. Pode ser usado em lambda or
lista-comp para executar uma lógica mais complexa, conforme mostrado em um dos exemplos a seguir.

Alguns exemplos de uso:

=> (se for verdade
... (fazer (imprimir "Efeitos colaterais rock!")
... (imprima "Sim, é mesmo!")))
Os efeitos colaterais são demais!
Sim, sério!

;; assumindo que (efeito colateral) é uma função que queremos chamar para cada
;; e todos os valores da lista, mas cujo valor de retorno não nos importamos
=> (list-comp (do (efeito colateral x)
... (se (< x 5) (* 2 x)
... (*4x)))
... (x (intervalo 10)))
[0, 2, 4, 6, 8, 20, 24, 28, 32, 36]

do pode aceitar qualquer número de argumentos, de 1 a n.

def / setv
def e setv são usados ​​para vincular um valor, objeto ou função a um símbolo. Por exemplo:

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

=> (contador setv (fn [item de coleção] (.count item de coleção)))
=> (contador [1 2 3 4 5 2 3] 2)
2

defclass
Novas classes são declaradas com defclass. Pode levar dois parâmetros opcionais: um vetor
definindo uma possível superclasse e outro vetor contendo atributos da nova
classe como dois vetores de itens.

(defclass nome da classe [superclasse-1 superclasse-2]
[[Valor do atributo]])

Valores e funções podem ser vinculados à nova classe, conforme mostrado no exemplo abaixo:

=> (defclass Gato []
... [[idade Nenhuma]
... [cor "branco"]
... [falar (fn [self] (imprimir "Miau"))]])

=> (ponto de definição (Gato))
=> (setv spot.colour "Preto")
'Preto'
=> (.speak spot)
Miau

definir / descontrair
definir e descontrair macros são usadas para definir funções. Eles tomam três parâmetros: o nome
da função a definir, um vetor de parâmetros, e as corpo da função:

(defn nome [parâmetros] corpo)

Os parâmetros podem ter as seguintes palavras-chave na frente deles:

&opcional
O parâmetro é opcional. O parâmetro pode ser fornecido como uma lista de dois itens, onde o
o primeiro elemento é o nome do parâmetro e o segundo é o valor padrão. O parâmetro
também pode ser fornecido como um único item; nesse caso, o valor padrão é nenhum.

=> (defn valor total [valor e opcional [imposto sobre valor agregado 10]]
... (+ (/ (* valor imposto sobre valor agregado) 100) valor))

=> (valor total 100)
110.0

=> (valor total 100 1)
101.0

&chave

&kwargs
O parâmetro conterá 0 ou mais argumentos de palavra-chave.

Os exemplos de código a seguir definem uma função que imprimirá todas as palavras-chave
argumentos e seus valores.

=> (defn parâmetros de impressão [&kwargs kwargs]
... (para [(, kv) (.items kwargs)] (imprimir kv)))

=> (aplicar parâmetros de impressão [] {"parâmetro-1" 1 "parâmetro-2" 2})
parâmetro-2 2
parâmetro-1 1

&descansar O parâmetro conterá 0 ou mais argumentos posicionais. Nenhuma outra posição
argumentos podem ser especificados após este.

O exemplo de código a seguir define uma função que pode receber de 0 a n valores numéricos
parâmetros. Em seguida, soma todos os números ímpares e subtrai todos os números pares.

=> (defn soma zig-zag [& números restantes]
(deixe [[números ímpares (list-comp x [x números] (ímpar? x))]
[números pares (list-comp x [x números] (par? x))]]
(- (soma dos números ímpares) (soma dos números pares))))

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

defn-alias / defun-alias
Novo na versão 0.10.0.

A defn-alias e defun-alias macros são muito parecidas definir, com a distinção que
em vez de definir uma função com um único nome, também podem definir aliases. Outro
do que pegar uma lista de símbolos para nomes de funções como o primeiro parâmetro, defn-alias e
defun-alias não são diferentes de definir e descontrair.

=> (defn-alias [alias do nome principal] []
... (imprima "Olá!"))
=> (nome principal)
"Olá!"
=> (alias)
"Olá!"

defmain
Novo na versão 0.10.1.

A defmain macro define uma função principal que é chamada imediatamente com sys.argv as
argumentos se e somente se este arquivo estiver sendo executado como um script. Em outras palavras, isto:

(defmain [&rest args]
(faça algo com argumentos))

é o equivalente a:

def principal(*args):
faça_algo_com(args)
retornar 0

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

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

Observe que, como você pode ver acima, se você retornar um número inteiro desta função, isso será
usado como status de saída do seu script. (O padrão do Python é sair do status 0, caso contrário,
o que significa que está tudo bem!)

(Desde (sys.exit 0) não é executado explicitamente no caso de um retorno não inteiro de
defmain, é uma boa ideia colocar (defmain) como o último trecho de código do seu arquivo.)

defmacro
defmacro é usado para definir macros. O formato geral é (defmacro nome [parâmetros]
exp).

O exemplo a seguir define uma macro que pode ser usada para trocar a ordem dos elementos no código,
permitindo ao usuário escrever código em notação infixa, onde o operador está entre o
operandos.

=> (infixo defmacro [código]
... (quase aspas (
... (sem aspas (obter código 1))
... (sem aspas (obter código 0))
... (sem aspas (obter código 2)))))

=> (infixo (1 + 1))
2

defmacro-alias
defmacro-alias é usado para definir macros com vários nomes (aliases). O formato geral
is (defmacro-alias [nomes] [parâmetros] exp). Ele cria múltiplas macros com o mesmo
lista de parâmetros e corpo, na lista de nomes especificada.

O exemplo a seguir define duas macros, ambas permitindo ao usuário escrever código em
notação infixa.

=> (defmacro-alias [infix infi] [código]
... (quase aspas (
... (sem aspas (obter código 1))
... (sem aspas (obter código 0))
... (sem aspas (obter código 2)))))

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

defmacro/g!
Novo na versão 0.9.12.

defmacro/g! é uma versão especial de defmacro que é usado para gerar automaticamente gensym
para qualquer símbolo que comece com g!.

Por exemplo, g!a se tornaria (gensym "a").

VEJA TAMBÉM:
Seção usando-gensym

defracionador
Novo na versão 0.9.12.

defracionador define uma macro de leitura, permitindo reestruturar ou modificar a sintaxe.

=> (desfrader ^ [expr] (imprimir expr))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Olá"
"Olá"

VEJA TAMBÉM:
Macros do leitor de seção

De
Novo na versão 0.9.12.

De remove um objeto do namespace atual.

=> (setv foo 42)
=> (del foo)
=> foo
Traceback (última chamada mais recente):
Arquivo " ", linha 1, em
NameError: o nome 'foo' não está definido

De também pode remover objetos de mapeamentos, listas e muito mais.

=> (teste setv (lista (intervalo 10)))
=> teste
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=> (del (teste de fatia 2 4)) ;; remover itens de 2 a 4 excluídos
=> teste
[0, 1, 4, 5, 6, 7, 8, 9]
=> (setv dic {"foo" "bar"})
=> dico
{"foo": "barra"}
=> (del (obter dic "foo"))
=> dico
{}

para
Novo na versão 0.10.1.

para é usado para simplificar uma sequência de chamadas de método para um objeto.

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

=> (coleção setv [])
=> (.append coleção 1)
=> (.append coleção 2)
=> (coleção .reverse)
=> coleção
[2 1]

avaliação
avaliação avalia uma expressão entre aspas e retorna o valor.

=> (eval '(imprimir "Olá Mundo"))
"Olá Mundo"

avaliar e compilar
avaliar quando compilar
primeiro / carro
primeiro e carro são macros para acessar o primeiro elemento de uma coleção:

=> (primeiro (intervalo 10))
0

para
para é usado para chamar uma função para cada elemento em uma lista ou vetor. Os resultados de cada
chamada é descartada e o para expressão retorna nenhum em vez de. O código de exemplo itera
Acima de coleção e para cada elemento in coleção chama o efeito colateral funcionar com
elemento como seu argumento:

;; assumindo que (efeito colateral) é uma função que leva um único parâmetro
(para [coleção de elementos] (elemento de efeito colateral))

;; for pode ter um bloco else opcional
(para [coleção de elementos] (elemento de efeito colateral)
(outro (efeito colateral-2)))

O opcional outro bloco só é executado se o para o loop termina normalmente. Se o
a execução é interrompida com quebrar, outro bloco não é executado.

=> (para [elemento [1 2 3]] (se (<elemento 3)
... (elemento de impressão)
... (quebrar))
... (else (imprimir "loop concluído")))
1
2

=> (para [elemento [1 2 3]] (se (<elemento 4)
... (elemento de impressão)
... (quebrar))
... (else (imprimir "loop concluído")))
1
2
3
loop concluído

geneexpr
geneexpr é usado para criar expressões geradoras. São necessários dois ou três parâmetros. O
o primeiro parâmetro é a expressão que controla o valor de retorno, enquanto o segundo é usado
para selecionar itens de uma lista. O terceiro e opcional parâmetro pode ser usado para filtrar
alguns dos itens da lista com base em uma expressão condicional. geneexpr é similar a
lista-comp, exceto que retorna um iterável que avalia os valores um por um em vez de
avaliando-os imediatamente.

=> (coleção def (intervalo 10))
=> (def filtrado (genexpr x [x coleção] (par? x)))
=> (lista filtrada)
[0, 2, 4, 6, 8]

gensym
Novo na versão 0.9.12.

gensym é usado para gerar um símbolo único que permite que macros sejam escritas sem
conflitos acidentais de nomes de variáveis.

=> (gensym)
você':G_1235'

=> (gensym "x")
você':x_1236'

VEJA TAMBÉM:
Seção usando-gensym

ter
ter é usado para acessar elementos únicos em listas e dicionários. ter leva dois parâmetros:
que o dados, estrutura e os votos de índice or chave do item. Em seguida, ele retornará o correspondente
valor do dicionário ou da lista. Exemplo de uso:

=> (deixe [[animais {"cachorro" "latir" "gato" "miau"}]
... [números ["zero" "um" "dois" "três"]]]
... (imprimir (obter animais "cachorro"))
... (imprimir (obter números 2)))
casca
dois

NOTA:
ter gera um KeyError se um dicionário for consultado em busca de uma chave inexistente.

NOTA:
ter gera um IndexError se uma lista ou tupla for consultada em busca de um índice que está fora de
limites.

global
global pode ser usado para marcar um símbolo como global. Isso permite que o programador atribua um
valor para um símbolo global. Ler um símbolo global não requer o global palavra-chave -
apenas atribuí-lo faz.

O exemplo a seguir mostra como o símbolo global a é atribuído um valor em uma função e
é posteriormente impresso em outra função. Sem o global palavra-chave, a segunda função
teria jogado um NomeErro.

(defn set-a [valor]
(global a)
(definir um valor))

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

(conjunto-a 5)
(imprimir-a)

if / se não
Novo na versão 0.10.0: se não

if é usado para selecionar condicionalmente o código a ser executado. Tem que conter uma condição
bloco e o bloco a ser executado se o bloco de condição for avaliado como Verdadeiro. Opcionalmente,
pode conter um bloco final que é executado caso a avaliação da condição seja
Falso.

se não é semelhante, mas o segundo bloco será executado quando a condição falhar enquanto
o terceiro e último bloco é executado quando o teste for bem-sucedido - a ordem oposta de if.

Exemplo de uso:

(se (dinheiro sobrando? conta)
(imprima "vamos às compras")
(imprima "vamos trabalhar"))

(se não (dinheiro sobrando? conta)
(imprima "vamos trabalhar")
(imprima "vamos às compras"))

A veracidade do Python é respeitada. nenhum, Falso, zero de qualquer tipo numérico, uma sequência vazia,
e um dicionário vazio são considerados Falso; todo o resto é considerado Verdadeiro.

lisp-se / lif e lisp-se-não / vida-não
Novo na versão 0.10.0.

Novo na versão 0.10.2: lisp-if-not /lif-not

Para quem prefere um estilo mais Lispy if cláusula, temos lisp-seou lif. Este só considera
nenhum / zero ser falso! Todos os outros valores Python "falso" são considerados verdadeiros.
Por outro lado, temos lisp-se-não e vida-não em paralelo a if e se não que inverte
a comparação.

=> (lisp-if Verdadeiro "verdadeiro" "falso")
"verdadeiro"
=> (lisp-if Falso "verdadeiro" "falso")
"verdadeiro"
=> (lisp-if 0 "verdadeiro" "falso")
"verdadeiro"
=> (lisp-if nil "verdadeiro" "falso")
"falso"
=> (lisp-if None "verdadeiro" "falso")
"falso"
=> (lisp-se-não nulo "verdadeiro" "falso")
"verdadeiro"
=> (lisp-se-não Nenhum "verdadeiro" "falso")
"verdadeiro"
=> (lisp-se-não Falso "verdadeiro" "falso")
"falso"

; Equivalente, mas mais curto
=> (se Verdadeiro "verdadeiro" "falso")
"verdadeiro"
=> (vida nula "verdadeiro" "falso")
"falso"
=> (lif-not None "verdadeiro" "falso")
"verdadeiro"

importar
importar é usado para importar módulos, como em Python. Existem várias maneiras que importar pode
ser usado.

;; Importa cada um desses módulos
;;
;; Pitão:
;; sistema de importação
;; importar os.path
(importar sys os.path)

;; Importar de um módulo
;;
;; Python: da importação de os.path existe, isdir, isfile
(importar [os.path [existe isdir isfile]])

;; Importar com um alias
;;
;; Python: importe sys como systest
(importar [sys: como systest])

;; Você pode listar quantas importações quiser de diferentes tipos.
(importar [tests.resources [função kwtest-com-um-traço]]
[os.path [existe isdir isfile]]
[sys: como teste do sistema])

;; Importe todas as funções do módulo para o namespace atual
(importar [sys [*]])

lambda / fn
lambda e fn pode ser usado para definir uma função anônima. Os parâmetros são semelhantes a
definir: o primeiro parâmetro é um vetor de parâmetros e o restante é o corpo do
função. lambda retorna uma nova função. No exemplo a seguir, uma função anônima
é definido e passado para outra função para filtrar a saída.

=> (def pessoas [{:nome "Alice": idade 20}
... {:nome "Bob": idade 25}
... {:nome "Charlie":idade 50}
... {:nome "Dave": idade 5}])

=> (defn display-people [filtro de pessoas]
... (para [pessoa pessoas] (if (filtro pessoa) (imprimir (:nome pessoa)))))

=> (exibir pessoas pessoas (fn [pessoa] (< (:idade pessoa) 25)))
Alice
Dave

Assim como nas definições normais de funções, se o primeiro elemento do corpo for uma string, ele
serve como uma doutrina. Isso é útil para fornecer docstrings aos métodos de classe.

=> (setv vezes-três
... (fn [x]
... "Multiplica a entrada por três e retorna o resultado."
... (* x 3)))

Isso pode ser confirmado através do recurso interno do Python ajudar função:

=> (ajuda vezes três)
Ajuda na função times_três:

vezes_três(x)
Multiplica a entrada por três e retorna o resultado
(FIM)

último
Novo na versão 0.10.2.

último pode ser usado para acessar o último elemento de uma coleção:

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

deixar
deixar é usado para criar variáveis ​​com escopo léxico. Eles são criados no início do
deixar forma e deixam de existir após a forma. O exemplo a seguir mostra isso
comportamento:

=> (deixe [[x 5]] (imprimir x)
... (deixe [[x 6]] (imprimir x))
... (imprimir x))
5
6
5

A deixar macro leva dois parâmetros: um vetor que define variáveis e os votos de corpo que fica
executado. variáveis é um vetor onde cada elemento é uma única variável ou um vetor
definindo um par de valores variáveis. No caso de uma única variável, é atribuído o valor
nenhum; caso contrário, o valor fornecido será usado.

=> (deixe [x [y 5]] (imprimir xy))
Nenhum 5

lista-comp
lista-comp executa compreensões de lista. São necessários dois ou três parâmetros. O primeiro
parâmetro é a expressão que controla o valor de retorno, enquanto o segundo é usado para
selecione itens de uma lista. O terceiro e opcional parâmetro pode ser usado para filtrar alguns
dos itens da lista com base em uma expressão condicional. Alguns exemplos:

=> (coleção def (intervalo 10))
=> (list-comp x [x coleção])
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

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

=> (list-comp (* x 2) [x coleção] (< x 5))
[0, 2, 4, 6, 8]

não
não é usado em expressões lógicas. Leva um único parâmetro e retorna um valor invertido
valor de verdade. Se Verdadeiro é dado como parâmetro, Falso serão devolvidos e vice-versa.
Exemplo de uso:

=> (não é verdade)
Falso

=> (não falso)
Verdadeiro

=> (não nenhum)
Verdadeiro

or
or é usado em expressões lógicas. São necessários pelo menos dois parâmetros. Ele retornará o
primeiro parâmetro não falso. Se tal valor não existir, o último parâmetro será retornado.

=> (ou Verdadeiro Falso)
Verdadeiro

=> (e Falso Falso)
Falso

=> (e Falso 1 Verdadeiro Falso)
1

NOTA:
or entra em curto-circuito e para de avaliar os parâmetros assim que o primeiro valor verdadeiro é
encontrados.

=> (ou True (imprima "olá"))
Verdadeiro

impressão
impressão é usado para saída na tela. Exemplo de uso:

(imprima "Olá, mundo!")

NOTA:
impressão sempre retorna nenhum.

quase-citação
quase-citação permite citar um formulário, mas também avaliar expressões seletivamente.
Expressões dentro de um quase-citação pode ser avaliado seletivamente usando Unquote (~). O
forma avaliada também pode ser emendada usando unquote-splice (~@). Quasiquote também pode ser
escrito usando aspas (`) símbolo.

;; seja `qux' uma variável com valor (bar baz)
`(foo ~qux)
; equivalente a '(foo (bar baz))
`(foo ~@qux)
; equivalente a '(foo bar baz)

citar
citar retorna o formulário passado para ele sem avaliá-lo. citar pode alternativamente ser
escrito usando o apóstrofo (') símbolo.

=> (setv x '(imprimir "Olá Mundo"))
; a variável x está definida como expressão e não avaliada
=>x
(u'print' u'Hello World')
=> (avaliação x)
Olá Mundo

requerer
requerer é usado para importar macros de um determinado módulo. É preciso pelo menos um parâmetro
especificando o módulo quais macros devem ser importadas. Vários módulos podem ser importados
com um único requerer.

O exemplo a seguir importará macros de Módulo 1 e Módulo 2:

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

resto / cdr
resto e cdr retorne a coleção passada como argumento sem o primeiro elemento:

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

conjunto-comp
conjunto-comp é usado para criar conjuntos. São necessários dois ou três parâmetros. O primeiro parâmetro é
para controlar o valor de retorno, enquanto o segundo é usado para selecionar itens de um
seqüência. O terceiro e opcional parâmetro pode ser usado para filtrar alguns dos itens em
a sequência baseada em uma expressão condicional.

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

fatia
fatia pode ser usado para pegar um subconjunto de uma lista e criar uma nova lista a partir dela. A forma
leva pelo menos um parâmetro especificando a lista a ser dividida. Dois parâmetros opcionais podem ser
usado para fornecer a posição inicial e final do subconjunto. Se não forem fornecidos, o
valor padrão de nenhum será usado em seu lugar. O terceiro parâmetro opcional é usado para
etapa de controle entre os elementos.

fatia segue as mesmas regras de sua contraparte Python. Índices negativos são contados
começando do final da lista. Alguns exemplos de uso:

=> (coleção def (intervalo 10))

=> (coleção de fatias)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

=> (coleção de fatias 5)
[5, 6, 7, 8, 9]

=> (coleção de fatias 2 8)
[2, 3, 4, 5, 6, 7]

=> (coleção de fatias 2 8 2)
[2, 4, 6]

=> (coleção de fatias -4 -2)
[6, 7]

jogar / aumentar
A jogar or aumentar formulários podem ser usados ​​para levantar uma Exceção em tempo de execução. Exemplo de uso:

(lançar)
; re-raspar a última exceção

(lança IOError)
; Lançar um IOError

(lançar (IOError "foobar"))
; Lançar um IOError("foobar")

jogar pode aceitar um único argumento (um Exceção classe ou instância) ou nenhum argumento para
re-aumentar o último Exceção.

tentar
A tentar formulário é usado para iniciar um tentar / captura bloquear. O formulário é usado da seguinte forma:

(experimentar
(função propensa a erros)
(catch [e ZeroDivisionError] (imprime "Divisão por zero"))
(senão (imprima "sem erros"))
(finalmente (imprima "tudo pronto")))

tentar deve conter pelo menos um captura bloco, e pode opcionalmente incluir um outro or finalmente
bloquear. Se um erro for gerado com um bloco catch correspondente durante a execução do
função propensa a erros, Que captura bloco será executado. Se nenhum erro for gerado, o outro
bloco é executado. O finalmente bloco será executado por último, independentemente de haver ou não um
erro foi gerado.

a menos que
A a menos que macro é uma abreviação para escrever um if declaração que verifica se o dado
condicional é Falso. O seguinte mostra a expansão desta macro.

(a menos que declaração condicional)

(se condicional
nenhum
(fazer declaração))

Unquote
Dentro de uma forma quase citada, Unquote força a avaliação de um símbolo. Unquote é alias de
o til (~) símbolo.

(nome definido "Abraços")
(quasiquote (= nome (sem aspas)))
;=> (u'=' u'nome' u'Cuddles')

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

unquote-splice
unquote-splice força a avaliação de um símbolo dentro de uma forma quase citada, bem como
Unquote. unquote-splice só pode ser usado quando o símbolo sem aspas contém um
valor iterável, pois "emenda" esse iterável na forma quase citada. unquote-splice is
alias ao ~@ símbolo.

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

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

quando
quando é similar a a menos que, exceto que testa quando a condicional fornecida é Verdadeiro. Não é
possível ter um outro bloquear em um quando macro. A seguir mostramos a expansão do
macro.

(quando declaração condicional)

(se condicional (fazer instrução))

enquanto
enquanto é usado para executar um ou mais blocos, desde que uma condição seja atendida. A seguir
exemplo irá gerar "Olá, mundo!" na tela indefinidamente:

(enquanto True (imprima "Olá, mundo!"))

com
com é usado para agrupar a execução de um bloco dentro de um gerenciador de contexto. O contexto
o gerente pode então configurar o sistema local e desmontá-lo de maneira controlada. O
exemplo arquetípico de uso com é ao processar arquivos. com pode vincular o contexto a um
argumento ou ignore-o completamente, conforme mostrado abaixo:

(com bloco [[arg (expr)]])

(com bloco [[(expr)]]

(com bloco [[arg (expr)] [(expr)]])

O exemplo a seguir abrirá o NOTÍCIAS arquivo e imprima seu conteúdo na tela. O
o arquivo é fechado automaticamente após ser processado.

(com [[f (abrir "NEWS")]] (imprimir (.ler f)))

com decorador
com decorador é usado para agrupar uma função com outra. A função que executa o
a decoração deve aceitar um único valor: a função que está sendo decorada, e retornar um novo
função. com decorador leva no mínimo dois parâmetros: a função que executa
decoração e a função que está sendo decorada. Mais de uma função de decorador pode ser
aplicado; eles serão aplicados na ordem do mais externo para o mais interno, ou seja. o primeiro
decorador será o mais externo e assim por diante. Decoradores com argumentos são chamados apenas
como uma chamada de função.

(com-decorador decorador-divertido
(defn alguma função [] ...)

(com decorador decorador1 decorador2 ...
(defn alguma função [] ...)

(com-decorador (decorador arg) ..
(defn alguma função [] ...)

No exemplo a seguir, inc-decorador é usado para decorar a função Adição com uma
função que recebe dois parâmetros e chama a função decorada com valores que são
incrementado em 1. Quando o decorado Adição é chamado com valores 1 e 1, o final
o 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-decorador [func]
... (fn [valor-1 valor-2] (func (+ valor-1 2) (+ valor-2 2))))

=> (with-decorator inc-decorator (defn adição [ab] (+ ab)))
=> (adição 1 1)
4
=> (com decorador inc2-decorador inc-decorador
... (defn adição [ab] (+ ab)))
=> (adição 1 1)
8

com-gensyms
Novo na versão 0.9.12.

com-gensym é usado para gerar um conjunto de gensym para uso em uma macro. O seguinte código:

(com-gensyms [abc]
...)

expande para:

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

VEJA TAMBÉM:
Seção usando-gensym

produzir
produzir é usado para criar um objeto gerador que retorna um ou mais valores. O gerador
é iterável e, portanto, pode ser usado em loops, compreensões de lista e outros similares
constrói.

A função Números aleatórios mostra como geradores podem ser usados ​​para gerar séries infinitas
sem consumir uma quantidade infinita de memória.

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

=> (multiplicar (intervalo 5) (intervalo 5))


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

=> (importar aleatoriamente)
=> (defn números aleatórios [baixo alto]
... (enquanto True (rendimento (.randint aleatório baixo alto))))
=> (list-comp x [x (tomar 15 (números aleatórios 1 50))])])
[7, 41, 6, 22, 32, 17, 5, 38, 18, 38, 17, 14, 23, 23, 19]

rendimento de
Novo na versão 0.9.13.

PITÃO 3.3 E UP SÓ!

rendimento de é usado para chamar um subgerador. Isso é útil se você quiser que sua rotina
ser capaz de delegar seus processos para outra rotina, digamos, se estiver usando algo sofisticado como
assíncio.

Hy núcleo
núcleo Funções
mas por último
Uso: (mas por último col)

Retorna um iterador de todos, exceto o último item em coll.

=> (lista (mas por último (intervalo 10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8]

=> (lista (mas por último [1]))
[]

=> (lista (mas por último []))
[]

=> (importar ferramentas iterativas)
=> (lista (take 5 (butlast (itertools.count 10))))
[10, 11, 12, 13, 14]

cara?
Novo na versão 0.10.0.

Uso: (col? x)

Returns Verdadeiro if x é iterável e não uma string.

=> (colo? [1 2 3 4])
Verdadeiro

=> (colo? {"a" 1 "b" 2})
Verdadeiro

=> (colo? "abc")
Falso

contras
Novo na versão 0.10.0.

Uso: (contras a b)

Devolve uma nova cela com carro a e cdr b.

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

=> (= 'hd (carro a))
Verdadeiro

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

contras?
Novo na versão 0.10.0.

Uso: (contras? foo)

Verifica se Foo é uma célula contras.

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

=> (contras? a)
Verdadeiro

=> (contras? zero)
Falso

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

dezembro
Uso: (dez x)

Retorna um a menos que x. Equivalente a (- x 1). Levanta Erro de tipo if (Não é (numérico? x)).

=> (3 de dezembro)
2

=> (0 de dezembro)
-1

=> (12.3 de dezembro)
11.3

desmontar
Novo na versão 0.10.0.

Uso: (desmontar árvore &opcional [codegen falso])

Descarte o Python AST para determinado Hy árvore para a saída padrão. Se codegen is Verdadeiro, a função
em vez disso, imprime código Python.

=> (desmontar '(imprimir "Olá mundo!"))
Módulo(
corpo=[
Expr(value=Call(func=Nome(id='print'), args=[Str(s='Olá mundo!')], palavras-chave=[], starargs=Nenhum, kwargs=Nenhum))])

=> (desmontar '(imprimir "Olá mundo!") verdadeiro)
print('Olá mundo!')

vazio?
Uso: (vazio? col)

Returns Verdadeiro if coll está vazia. Equivalente a (= 0 (len cole)).

=> (vazio? [])
Verdadeiro

=> (vazio? "")
Verdadeiro

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

todo?
Novo na versão 0.10.0.

Uso: (todo? antes col)

Returns Verdadeiro if (pred x) é lógico verdadeiro para todo x in coll, Caso contrário Falso. Retorna Verdadeiro
if coll está vazia.

=> (todos? pares? [2 4 6])
Verdadeiro

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

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

=> (todos? pares? [])
Verdadeiro

flutuador?
Uso: (flutuador? x)

Returns Verdadeiro if x é um flutuador.

=> (flutuar? 3.2)
Verdadeiro

=> (flutuar? -2)
Falso

até?
Uso: (até? x)

Returns Verdadeiro if x é par. Levanta Erro de tipo if (Não é (numérico? x)).

=> (par? 2)
Verdadeiro

=> (par? 13)
Falso

=> (par? 0)
Verdadeiro

identidade
Uso: (identidade x)

Retorna o argumento fornecido à função.

=> (identidade 4)
4

=> (lista (identidade do mapa [1 2 3 4]))
[1 2 3 4]

inc
Uso: (inc. x)

Retorna um a mais que x. Equivalente a (+ x 1). Levanta Erro de tipo if (Não é (numérico? x)).

=> (inc 3)
4

=> (inc 0)
1

=> (inc 12.3)
13.3

instância?
Uso: (instância? classe x)

Returns Verdadeiro if x é uma instância de classe.

=> (instância? float 1.0)
Verdadeiro

=> (instância? int 7)
Verdadeiro

=> (instância? str (str "foo"))
Verdadeiro

=> (defclass TestClass [objeto])
=> (setv inst (TestClass))
=> (instância? TestClass inst)
Verdadeiro

inteiro?
Uso: (inteiro? x)

Returns Verdadeiro if x é um número inteiro. Para Python 2, isso é int or longo. Para Python 3,
isto é int.

=> (inteiro? 3)
Verdadeiro

=> (inteiro? -2.4)
Falso

intercalar
Novo na versão 0.10.1.

Uso: (intercalar seq1 seq2 ...)

Retorna um iterável do primeiro item em cada uma das sequências, depois do segundo, etc.

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

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

interpor
Novo na versão 0.10.1.

Uso: (interpor item sequência)

Retorna um iterável dos elementos da sequência separados pelo item.

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

=> (lista (interpor -1 (intervalo 5)))
[0, -1, 1, -1, 2, -1, 3, -1, 4]

iterável?
Uso: (iterável? x)

Returns Verdadeiro if x é iterável. Objetos iteráveis ​​retornam um novo iterador quando (iter x) is
chamado. Contraste com iterador?.

=> ;; funciona para cordas
=> (iterável? (str "abcde"))
Verdadeiro

=> ;; funciona para listas
=> (iterável? [1 2 3 4 5])
Verdadeiro

=> ;; funciona para tuplas
=> (iterável? (, 1 2 3))
Verdadeiro

=> ;; funciona para dictos
=> (iterável? {:a 1 :b 2 :c 3})
Verdadeiro

=> ;; funciona para iteradores/geradores
=> (iterável? (repetir 3))
Verdadeiro

iterador?
Uso: (iterador? x)

Returns Verdadeiro if x é um iterador. Iteradores são objetos que retornam como um
iterador quando (iter x) é chamado. Contraste com iterável?.

=> ;; não funciona para uma lista
=> (iterador? [1 2 3 4 5])
Falso

=> ;; mas podemos obter um iter da lista
=> (iterador? (iter [1 2 3 4 5]))
Verdadeiro

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

=> ;; crie um iterador a partir do dict
=> (iterador? (iter {:a 1:b 2:c 3}))
Verdadeiro

Lista*
Uso: (lista* cabeça &descansar cauda)

Gera uma cadeia de células cons aninhadas (uma lista pontilhada) contendo os argumentos. Se o
a lista de argumentos possui apenas um elemento, retorne-o.

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

macroexpandir
Novo na versão 0.10.0.

Uso: (macroexpansão Formato)

Retorna a expansão macro completa de formulário.

=> (macroexpandir '(-> (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')

macroexpansão-1
Novo na versão 0.10.0.

Uso: (macroexpansão-1 Formato)

Retorna a expansão macro de etapa única de formulário.

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

fundir com
Novo na versão 0.10.1.

Uso: (fundir com f &descansar mapas)

Retorna um mapa que consiste no restante dos mapas unidos primeiro. Se uma chave ocorrer em
mais de um mapa, o(s) mapeamento(s) deste último (da esquerda para a direita) serão combinados com
o mapeamento no resultado chamando (f val-em-resultado val-no-último).

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

negativo?
Uso: (neg? x)

Returns Verdadeiro if x é menor que zero. Levanta Erro de tipo if (Não é (numérico? x)).

=> (neg? -2)
Verdadeiro

=> (neg? 3)
Falso

=> (neg? 0)
Falso

nada?
Uso: (nada? x)

Returns Verdadeiro if x is zero / nenhum.

=> (zero? zero)
Verdadeiro

=> (zero? Nenhum)
Verdadeiro

=> (zero? 0)
Falso

=> (setf x nulo)
=> (zero? x)
Verdadeiro

=> ;; list.append sempre retorna Nenhum
=> (nulo? (.append [1 2 3] 4))
Verdadeiro

Nenhum?
Uso: (nenhum? x)

Returns Verdadeiro if x is nenhum.

=> (nenhum? Nenhum)
Verdadeiro

=> (nenhum? 0)
Falso

=> (setf x Nenhum)
=> (nenhum? x)
Verdadeiro

=> ;; list.append sempre retorna Nenhum
=> (nenhum? (.append [1 2 3] 4))
Verdadeiro

enésimo
Uso: (enésimo coll n &opcional [predefinição nada])

Retorna o n-ésimo item em uma coleção, contando a partir de 0. Retorna o valor padrão, zero, Se
fora dos limites (a menos que especificado de outra forma). Levanta ValueError if n é negativo.

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

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

=> (zero? (enésimo [1 2 4 7] 5))
Verdadeiro

=> (enésimo [1 2 4 7] 5 "padrão")
'Default'

=> (enésimo (pegue 3 (descarte 2 [1 2 3 4 5 6])) 2))
5

=> (enésimo [1 2 4 7] -1)
Traceback (última chamada mais recente):
...
ValueError: Os índices para islice() devem ser Nenhum ou um número inteiro: 0 <= x <= sys.maxsize.

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

Returns Verdadeiro if x é um numérico, conforme definido no Python números.Número classe.

=> (numérico? -2)
Verdadeiro

=> (numérico? 3.2)
Verdadeiro

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

odd?
Uso: (chance? x)

Returns Verdadeiro if x é estranho. Levanta Erro de tipo if (Não é (numérico? x)).

=> (estranho? 13)
Verdadeiro

=> (estranho? 2)
Falso

=> (estranho? 0)
Falso

pos?
Uso: (pos? x)

Returns Verdadeiro if x é maior que zero. Levanta Erro de tipo if (Não é (numérico? x)).

=> (pos? 3)
Verdadeiro

=> (pos? -2)
Falso

=> (pos? 0)
Falso

segundo
Uso: (segundo col)

Retorna o segundo membro de coll. Equivalente a (obter coll 1).

=> (segundo [0 1 2])
1

alguns
Novo na versão 0.10.0.

Uso: (alguns antes col)

Retorna o primeiro valor logicamente verdadeiro de (pred x) para qualquer x in coll, Caso contrário zero.
Devolução zero if coll está vazia.

=> (alguns até? [2 4 6])
Verdadeiro

=> (zero? (alguns até? [1 3 5]))
Verdadeiro

=> (nil? (alguma identidade [0 "" []]))
Verdadeiro

=> (alguma identidade [0 "string não vazia" []])
'string não vazia'

=> (zero? (alguns até? []))
Verdadeiro

fragmento?
Uso: (corda? x)

Returns Verdadeiro if x é uma string.

=> (string? "foo")
Verdadeiro

=> (sequência? -2)
Falso

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

Returns Verdadeiro if x é um símbolo.

=> (símbolo? 'foo)
Verdadeiro

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

zero?
Uso: (zero? x)

Returns Verdadeiro if x é zero.

=> (zero? 3)
Falso

=> (zero? -2)
Falso

=> (zero? 0)
Verdadeiro

Seqüência Funções
Funções de sequência podem criar ou operar em uma sequência potencialmente infinita sem
exigindo que a sequência seja totalmente realizada em uma lista ou contêiner semelhante. Eles fazem isso por
retornando um iterador Python.

Podemos usar o gerador canônico de números infinitos de Fibonacci como exemplo de como usar
algumas dessas funções.

(definição mentira []
(definir a 0)
(conjunto b 1)
(embora seja verdade
(rendimento a)
(setv (, ab) (, b (+ ab)))))

Note o (enquanto verdadeiro ...) laço. Se executarmos isso no REPL,

=> (mentira)


Chamar a função retorna apenas um iterador, mas não funciona até que o consumamos.
Tentar algo assim não é recomendado, pois o loop infinito será executado até
consome toda a RAM disponível ou, neste caso, até que eu a mate.

=> (lista (mentira))
[1] 91474 mortos por

Para obter os primeiros 10 números de Fibonacci, use levar. Observe que levar também retorna um gerador,
então eu crio uma lista a partir dela.

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

Para obter o número de Fibonacci no índice 9 (começando em 0):

=> (enésimo (fib) 9)
34

ciclo
Uso: (ciclo col)

Retorna um iterador infinito dos membros de col.

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

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

distinto
Uso: (distinto col)

Retorna um iterador contendo apenas os membros únicos em 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]

cair
Uso: (derrubar n col)

Retorna um iterador, ignorando o primeiro n membros de coll. Levanta ValueError 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]))
[]

último lançamento
Uso: (gota-último n col)

Retorna um iterador de todos, exceto o último n itens em coll. Levanta ValueError if n is
negativo.

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

=> (lista (drop-último 0 (intervalo 5)))
[0, 1, 2, 3, 4]

=> (lista (drop-último 100 (intervalo 100)))
[]

=> (importar ferramentas iterativas)
=> (lista (take 5 (drop-last 100 (itertools.count 10))))
[10, 11, 12, 13, 14]

cair enquanto
Uso: (gota enquanto antes col)

Retorna um iterador, ignorando membros de coll até antes is Falso.

=> (lista (descartar enquanto par? [2 4 7 8 9]))
[7, 8, 9]

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

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

filtro
Uso: (filtro antes col)

Retorna um iterador para todos os itens em coll que passa o predicado antes.

Veja também remover.

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

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

achatar
Novo na versão 0.9.12.

Uso: (achatar col)

Retorna uma única lista de todos os itens em coll, achatando todas as listas contidas e/ou
tuplas.

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

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

iterar
Uso: (iterar fn x)

Retorna um iterador de x, fn(x), fn(fn(x)), etc.

=> (lista (tomar 5 (iterar inc 5)))
[5, 6, 7, 8, 9]

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

ler
Uso: (ler &opcional [De arquivo eof])

Lê a próxima expressão Hy de De arquivo (padronizado para sys.stdin) e pode levar um
byte único como EOF (o padrão é uma string vazia). Levanta Erro EOF if De arquivo termina antes
uma expressão completa pode ser analisada.

=> (ler)
(+2)
('+' 2 2)
=> (avaliar (ler))
(+2)
4

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

=> ; assumindo que "example.hy" contém:
=> ; (imprima "olá")
=> ; (imprima "hiamigos!")
=> (com [[f (abrir "example.hy")]]
... (tentar
... (embora seja verdade
... (deixe [[exp (ler f)]]
... (fazer
... (imprimir "OHY" exp)
... (avaliação exp))))
... (catch [e EOFError]
... (imprimir "EOF!"))))
OHY ('imprimir' 'olá')
Olá
OHY ('imprimir' 'amigos!')
amigos!
EOF!

remover
Uso: (retirar antes col)

Retorna um iterador de coll com elementos que passam o predicado, antes, removido.

Veja também filtro.

=> (lista (remover ímpar? [1 2 3 4 5 6 7]))
[2, 4, 6]

=> (lista (remover posição? [1 2 3 4 5 6 7]))
[]

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

repetir
Uso: (repita x)

Retorna um iterador (infinito) de x.

=> (lista (pegue 6 (repita "s")))
[você', você', você', você', você', você']

repetidamente
Uso: (repetidamente f)

Retorna um iterador chamando fn repetidamente.

=> (importar [aleatório [randint]])

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

levar
Uso: (pegar n col)

Retorna um iterador contendo o primeiro n membros de coll. Levanta ValueError if n is
negativo.

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

=> (lista (pegue 4 (repita "s")))
[você', você', você', você']

=> (lista (pegue 0 (repita "s")))
[]

take-nth
Uso: (tomar o enésimo n col)

Retorna um iterador contendo cada n-º membro de coll.

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

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

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

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

espere um pouco
Uso: (demore um pouco antes col)

Retorna um iterador de coll enquanto antes Retorna Verdadeiro.

=> (lista (posição de espera? [1 2 3 -4 5]))
[1, 2, 3]

=> (lista (demore um pouco neg? [-4 -3 1 2 5]))
[-4, -3]

=> (lista (demore um pouco neg? [1 2 3 -4 5]))
[]

zip com
Novo na versão 0.9.13.

Uso: (zip com fn coll ...)

Equivalente a zip, mas usa uma função com vários argumentos em vez de criar uma tupla. Se
zip com é chamado com N coleções, então fn deve aceitar N argumentos.

=> (operador de importação)
=> (lista (zipcom operador.add [1 2 3] [4 5 6]))
[5, 7, 9]

Leitor Macros
As macros de leitura dão ao Lisp o poder de modificar e alterar a sintaxe instantaneamente. Você não quer
Notação polonesa? Uma macro de leitura pode facilmente fazer exatamente isso. Quer o jeito de Clojure de ter um
expressão regular? As macros do leitor também podem fazer isso facilmente.

Sintaxe
=> (desfrader ^ [expr] (imprimir expr))
=> #^(1 2 3 4)
(1 2 3 4)
=> #^"Olá"
"Olá"
=> #^1+2+3+4+3+2
1+2+3+4+3+2

Hy não tem literal para tuplas. Digamos que você não gosta (, ...) e quero outra coisa. Esse
é um problema que as macros de leitura são capazes de resolver de maneira organizada.

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

Você poderia até fazer como o Clojure e ter um literal para expressões regulares!

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

Implementação
defracionador leva um único caractere como nome do símbolo para a macro do leitor; mais nada
retornará um erro. Em termos de implementação, defracionador se expande em um lambda coberto por um
decorador. Este decorador salva o lambda em um dicionário com o nome do módulo e
símbolo.

=> (desfrader ^ [expr] (imprimir expr))
;=> (with_decorator (hy.macros.reader ^) (fn [expr] (imprimir expr)))

# se expande em (dispatch_reader_macro ...) onde o símbolo e a expressão são passados ​​para
a função correta.

=> #^()
;=> (dispatch_reader_macro ^ ())
=> #^"Olá"
"Olá"

AVISO:
Devido a uma limitação no lexer e analisador do Hy, as macros do leitor não podem redefinir
sintaxe como ()[]{}. Isto provavelmente será abordado no futuro.

Interno Hy Documentação
NOTA:
Esses bits são úteis principalmente para pessoas que hackeiam o próprio Hy, mas também podem ser usados ​​para
aqueles que se aprofundam na programação macro.

Hy Modelos
Introdução para Hy Modelos
Os modelos Hy são uma camada muito fina sobre objetos Python regulares, representando a fonte Hy
código como dados. Os modelos adicionam apenas informações de posição de origem e alguns métodos para
suporta manipulação limpa do código-fonte Hy, por exemplo em macros. Para conseguir isso
objetivo, os modelos Hy são mixins de uma classe Python base e HyObject.

HyObject
hy.models.HyObject é a classe base dos modelos Hy. Ele implementa apenas um método, substituir,
que substitui a posição de origem do objeto atual pela passada como argumento.
Isso nos permite acompanhar a posição original das expressões que são modificadas por
macros, seja no compilador ou em macros puras.

HyObject não se destina a ser usado diretamente para instanciar modelos Hy, mas apenas como um mixin
para outras aulas.

Compound Modelos
Listas entre parênteses e colchetes são analisadas como modelos compostos pelo analisador Hy.

HyList
hy.models.list.HyList é a classe base dos modelos Hy "iteráveis". Seu uso básico é
representar entre colchetes [] listas, que, quando usadas como uma expressão de nível superior, se traduzem em
Literais de lista Python na fase de compilação.

Adicionar uma HyList a outro objeto iterável reutiliza a classe do objeto do lado esquerdo,
um comportamento útil quando você deseja concatenar objetos Hy em uma macro, por exemplo.

HyExpression
hy.models.expression.HyExpression herda HyList para parênteses () expressões. O
O resultado da compilação dessas expressões depende do primeiro elemento da lista: o
o compilador despacha expressões entre formas especiais do compilador, macros definidas pelo usuário e
chamadas regulares de função Python.

HyDict
hy.models.dict.HyDict herda HyList para colchetes {} expressões, que compilam
até um literal de dicionário Python.

A decisão de usar uma lista em vez de um dict como classe base para HyDict permite mais fácil
manipulação de dictos em macros, com o benefício adicional de permitir expressões compostas
como chaves de dict (como, por exemplo, o HyExpression A classe Python não é hash).

Atomic Modelos
No fluxo de entrada, strings entre aspas duplas, respeitando a notação Python para strings,
são analisados ​​como um único token, que é analisado diretamente como um HyString.

Uma sequência ininterrupta de caracteres, excluindo espaços, colchetes, aspas e aspas duplas
e comentários, é analisado como um identificador.

Os identificadores são resolvidos para modelos atômicos durante a fase de análise na seguinte ordem:

· HyInteger

· HyFloat

· HyComplex (se o átomo não for vazio j)

· HyKeyword (se o átomo começar com :)

· HySímbolo

HyString
hy.models.string.HyString é a classe base dos modelos Hy equivalentes a strings. Isso também
representa literais de string entre aspas duplas, "", que compila para string unicode
literais em Python. HyStrings herdar objetos unicode em Python 2 e objetos string em
Python 3 (e, portanto, não dependem de codificação).

HyString modelos baseados são imutáveis.

Strings literais Hy podem abranger várias linhas e são consideradas pelo analisador como uma única
unit, respeitando os escapes do Python para strings unicode.

Numérico Modelos
hy.models.integer.HyInteger representa literais inteiros (usando o longo digite em Python 2,
e int em Python 3).

hy.models.float.HyFloat representa literais de ponto flutuante.

hy.models.complex.HyComplex representa literais complexos.

Os modelos numéricos são analisados ​​usando a rotina Python correspondente e python numérico válido
literais serão transformados em sua contraparte Hy.

HySímbolo
hy.models.symbol.HySymbol é o modelo usado para representar símbolos na linguagem Hy. Isto
herda HyString.

HySímbolo objetos são mutilados na fase de análise, para ajudar na interoperabilidade do Python:

· Símbolos cercados por asteriscos (*) são transformados em letras maiúsculas;

· Traços (-) são transformados em sublinhados (_);

· Um ponto de interrogação final (?) se tornou um líder é_.

Advertência: como a manipulação é feita durante a fase de análise, é possível
gerar programaticamente HySymbols que não podem ser gerados com o código-fonte Hy. Tal
mecanismo é usado pelo gensym para gerar símbolos "não internados".

HyKeyword
hy.models.keyword.HyKeyword representa palavras-chave em Hy. Palavras-chave são símbolos que começam com
a :. A classe herda HyString.

Distinguir HyKeywords da HySímbolos, sem a possibilidade de (involuntário)
confrontos, o caractere unicode de uso privado "\uFDD0" é anexado à palavra-chave literal
antes do armazenamento.

Desvantagens Células
hy.models.cons.HyCons é uma representação compatível com Python contras células. As células contras são
especialmente útil para imitar recursos de variantes "usuais" do LISP, como Scheme ou Common
Lisp.

Uma célula cons é um objeto de 2 itens, contendo um carro (cabeça) e um cdr (cauda). Em algum Lisp
variantes, a célula cons é o bloco de construção fundamental, e as expressões S são, na verdade,
representado como listas vinculadas de células cons. Este não é o caso em Hy, como de costume
expressões são feitas de listas Python envolvidas em um HyExpression. No entanto, o HyCons
imita o comportamento das variantes "usuais" do Lisp assim:

· (contras algo nada) is (HyExpressão [algo])

· (contras algo alguma lista) is ((tipo alguma lista) (+ [algo] alguma lista)) (E se
alguma lista herda de Lista).

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

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

Hy suporta uma sintaxe de lista pontilhada, onde '(a . b) significa (contras 'a 'b) e '(a b . c) significa
(contras 'a (contras 'b 'c)). Se o compilador encontrar uma célula cons no nível superior, ele gerará
um erro de compilação.

HyCons envolve os argumentos passados ​​(car e cdr) em tipos Hy, para facilitar a manipulação de
contras células em um contexto macro.

Hy Interno TEORIA
Visão geral
Os componentes internos do Hy funcionam agindo como um front-end para o bytecode Python, de modo que o próprio Hy
compila para Python Bytecode, permitindo que um tempo de execução Python não modificado execute código Hy,
mesmo sem perceber.

A maneira como fazemos isso é traduzindo Hy em uma estrutura de dados AST interna do Python, e
construindo esse AST em bytecode Python usando módulos do padrão Python
biblioteca, para que não tenhamos que duplicar todo o trabalho interno do Python para cada
versão única do Python.

Hy funciona em quatro etapas. As seções a seguir cobrirão cada etapa do Hy desde a origem até
tempo de execução.

Passos 1 e 2: Tokenizing e Análise
O primeiro estágio da compilação do Hy é transformar a fonte em tokens com os quais possamos lidar. Nós
use um projeto chamado rply, que é um analisador muito bom (e rápido), escrito em um subconjunto
do Python chamado rpython.

O código lexing é todo definido em hy.lex.lexer. Este código está principalmente definindo o Hy
gramática, e todas as partes realmente difíceis são resolvidas pelo rply - apenas definimos
"retornos de chamada" para resposta em hy.lex.parser, que pega os tokens gerados e retorna o
Modelos Hy.

Você pode pensar nos modelos Hy como o "AST" para Hy, é onde as macros operam
(diretamente), e é o que o compilador usa quando compila Hy down.

VEJA TAMBÉM:
Seção Hy Modelos para obter mais informações sobre os modelos Hy e o que eles significam.

Passo 3: Hy Compilação para Python AST
É aqui que acontece a maior parte da magia em Hy. É aqui que levamos Hy AST (os modelos),
e compile-os em Python AST. Algumas coisas estranhas acontecem aqui para resolver alguns
problemas no AST, e trabalhar no compilador é um dos trabalhos mais importantes que fazemos
ter.

O compilador é um pouco complexo, então não se sinta mal se você não entender isso na primeira tentativa,
pode demorar um pouco para acertar.

O principal ponto de entrada para o compilador é HyASTCompiler.compile. Este método é invocado e
o único método "público" real na classe (ou seja, não prometemos realmente o
API além desse método).

Na verdade, mesmo internamente, quase nunca recorremos diretamente, quase sempre forçamos
a árvore Hy através compilar, e geralmente fará isso com subelementos de uma expressão
que temos. Cabe ao despachante baseado em tipo despachar adequadamente os subelementos.

Todos os métodos que pré-formam uma compilação são marcados com o @construções() decorador. Você pode
passe a classe do modelo Hy que ele compila ou você pode usar uma string para
expressões. Vou esclarecer isso em um segundo.

Primeiro nome Etapa Tipo-Despacho
Vamos começar no compilar método. A primeira coisa que fazemos é verificar o tipo da coisa
estamos construindo. Procuramos ver se temos um método que possa construir o modelo() que
tem e envia para o método que pode lidar com isso. Se não tivermos nenhum método que possa
construir esse tipo, levantamos um interno Exceção.

Por exemplo, se tivermos um HyString, temos um mapeamento quase 1 para 1 de Hy AST para Python
AST. O compile_string método leva o HyString, e retorna um ast.Str()
preenchido com os números de linha e conteúdo corretos.

Macro-expansão
Se conseguirmos um HyExpression, tentaremos ver se esta é uma macro conhecida e pressionaremos para ter
expandiu-se invocando hy.macros.macroexpand, em seguida, empurre o resultado de volta para
HyASTCompiler.compile.

Segundo Etapa Despacho de Expressão
O único caso especial é o HyExpression, já que precisamos criar AST diferentes dependendo
no formulário especial em questão. Por exemplo, quando atingimos um (E se verdadeiro verdadeiro falso), nós
preciso gerar um ast.See compile corretamente os subnós. É aqui que @construções()
com uma String como argumento entra.

Para o expressão_compilada (que é definido com um @builds(HyExpression)) enviará
com base na string do primeiro argumento. Se, por alguma razão, o primeiro argumento não for
uma string, ele também lidará adequadamente com esse caso (provavelmente levantando um Exceção).

Se a String não for conhecida por Hy, o padrão será criar um ast.Chamada, que tentará
faça uma chamada de tempo de execução (em Python, algo como foo ()).

Questões Acertar com Python AST
Python AST é ótimo; foi o que nos permitiu escrever um projeto tão poderoso além
Python sem ter que lutar muito contra Python. Como qualquer coisa, tivemos nosso quinhão de
problemas, e aqui está uma pequena lista dos mais comuns que você pode encontrar.

Python diferencia entre Demonstrações e Expressões.

Isso pode não parecer grande coisa - na verdade, para a maioria dos programadores Python, isso irá
em breve se tornará um momento "Bem, sim".

Em Python, fazendo algo como:

impressão para x in alcance(10) passar, Porque impressão imprime expressões e para não é um
expressão, é uma instrução de fluxo de controle. Coisas como 1 + 1 são expressões, como é lambda
x: 1 + x, mas outros recursos de linguagem, como if, paraou enquanto são declarações.

Como eles não têm "valor" para Python, isso torna difícil trabalhar em Hy, já que fazer algo
como (impressão (E se verdadeiro verdadeiro falso)) não é apenas comum, é esperado.

Como resultado, nós auto-mutilamos as coisas usando um Resultado objeto, onde oferecemos qualquer ast.stmt
que precisam ser executados, e um único ast.expr que pode ser usado para obter o valor de qualquer coisa
foi apenas executado. Hy faz isso forçando a atribuição de coisas durante a execução.

Por exemplo, o Hy:

(imprimir (se verdadeiro verdadeiro falso))

Se transformará em:

se for verdade:
_mangled_name_here = Verdadeiro
outro:
_mangled_name_here = Falso

imprima _mangled_name_aqui

OK, isso foi um pouco mentiroso, já que na verdade transformamos essa afirmação em:

imprime Verdadeiro se Verdadeiro, senão Falso

Ao forçar as coisas a um ast.expr se pudermos, mas a ideia geral se mantém.

Passo 4: Python Bytecode saída e Runtime
Depois que tivermos uma árvore Python AST completa, podemos tentar compilá-la em Python
bytecode empurrando-o através avaliação. De agora em diante, não estaremos mais no controle, e
Python está cuidando de tudo. É por isso que coisas como tracebacks do Python, pdb e
Aplicativos Django funcionam.

Hy Macros
utilização gensym para Mais segura Macros
Ao escrever macros, deve-se ter cuidado para evitar capturar variáveis ​​externas ou usar
nomes de variáveis ​​que podem entrar em conflito com o código do usuário.

Usaremos um exemplo de macro nif (Vejo
http://letoverlambda.com/index.cl/guest/chap3.html#sec_5 para uma descrição mais completa.)
nif é um exemplo, algo como um número if, onde com base na expressão, um dos
3 formas são chamadas dependendo se a expressão é positiva, zero ou negativa.

Uma primeira passagem pode ser algo como:

(defmacro nif [expr forma pos forma zero forma negativa]
`(deixe [[nome obscuro ~expr]]
(cond [(pos? nome obscuro) ~pos-form]
[(zero? nome obscuro) ~ forma zero]
[(neg? nome obscuro) ~ forma negativa])))

onde nome obscuro é uma tentativa de escolher algum nome de variável para não entrar em conflito com outros
código. Mas é claro que, embora bem-intencionado, isso não é garantia.

O método gensym foi projetado para gerar um símbolo novo e único exatamente para essa ocasião.
Uma versão muito melhor nif seria:

(defmacro nif [expr forma pos forma zero forma negativa]
(deixe [[g (gensym)]]
`(deixe [[~g ~expr]]
(cond [(pos? ~g) ~pos-forma]
[(zero? ~g) ~forma zero]
[(neg? ~g) ~forma negativa]))))

Este é um caso fácil, pois existe apenas um símbolo. Mas se houver necessidade de vários
gensym's, há uma segunda macro with-gensyms que basicamente se expande para uma série de deixar
afirmações:

(com-gensyms [abc]
...)

expande para:

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

então nosso reescrito nif pareceria:

(defmacro nif [expr forma pos forma zero forma negativa]
(com-gensyms [g]
`(deixe [[~g ~expr]]
(cond [(pos? ~g) ~pos-forma]
[(zero? ~g) ~forma zero]
[(neg? ~g) ~forma negativa]))))

Finalmente, podemos fazer uma nova macro que faça tudo isso para nós. defmacro/g! vou levar
todos os símbolos que começam com g! e ligue automaticamente gensym com o restante
símbolo. Então g!a se tornaria (gensym "a").

Nossa versão final de nifconstruído com defmacro/g! torna-se:

(defmacro/g! nif [expr forma pos forma zero forma negativa]
`(deixe [[~g!res ~expr]]
(cond [(pos? ~g!res) ~pos-forma]
[(zero? ~g!res) ~forma zero]
[(neg? ~g!res) ~forma negativa]))))

Checagem Macro Argumentos e Aumentar Exceções
Hy Compilador Built-Ins

CONTRIBUINTE MÓDULOS ÍNDICE

Conteúdo:

Anafórico Macros
Novo na versão 0.9.12.

O módulo de macros anafóricas torna a programação funcional em Hy muito concisa e fácil de
ler.
Uma macro anafórica é um tipo de macro de programação que captura deliberadamente alguma forma
fornecida à macro que pode ser referida por uma anáfora (uma expressão referente
para outro). - Wikipédia (http://en.wikipedia.org/wiki/Anaphoric_macro)

Macros
ap-se
Uso: (ap-se (foo) (impressão isto))

Avalia a primeira forma quanto à veracidade e vincula-a a it tanto no verdadeiro quanto no falso
galhos.

um pêssego
Uso: (um pêssego [1 2 3 4 5] (impressão isto))

Avalie o formulário de cada elemento da lista para efeitos colaterais.

ap-de cada vez
Uso: (ap-cada-enquanto Lista antes corpo)

Avalie o formulário para cada elemento onde o formulário predicado retorna Verdadeiro.

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

mapa-ap
Uso: (ap-mapa formulário Lista)

A forma anafórica do mapa funciona como um mapa normal, exceto que em vez de uma função
objeto, ele assume a forma Hy. O nome especial it está vinculado ao objeto atual do
lista na iteração.

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

ap-map-quando
Uso: (ap-map-quando predfn rep Lista)

Avalie um mapeamento na lista usando uma função de predicado para determinar quando aplicar o
.

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

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

filtro ap
Uso: (ap-filtro formulário Lista)

Como com mapa-ap tomamos uma forma especial em vez de uma função para filtrar os elementos do
lista. O nome especial it está vinculado ao elemento atual na iteração.

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

ap-rejeitar
Uso: (ap-rejeitar formulário Lista)

Esta função faz o oposto de filtro ap, ele rejeita os elementos que passam pelo
predicado. O nome especial it está vinculado ao elemento atual na iteração.

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

ap-dotimes
Uso (ap-dotimes n corpo)

Esta função avalia o corpo n vezes, com a variável especial it vinculado de 0 para
1-n. É útil para efeitos colaterais.

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

ap-primeiro
Uso (ap-primeiro predfn Lista)

Esta função retorna o primeiro elemento que passa o predicado ou nenhum, Com o
variável especial it vinculado ao elemento atual na iteração.

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

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

Esta função retorna o último elemento que passa o predicado ou nenhum, com o especial
variável it vinculado ao elemento atual na iteração.

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

ap-reduzir
Uso (ap-reduzir formulário Lista &opcional valor inicial)

Esta função retorna o resultado da aplicação do formulário aos 2 primeiros elementos do corpo e
aplicando o resultado e o terceiro elemento etc. até que a lista se esgote. Opcionalmente um
o valor inicial pode ser fornecido para que a função seja aplicada ao valor inicial e o
primeiro elemento. Isso expõe o elemento que está sendo iterado como it E a corrente
valor acumulado como acc.

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

loop/recorrência
Novo na versão 0.10.0.

A laço / recorrer macro oferece aos programadores uma maneira simples de usar a otimização de chamada final (TCO)
em seu código Hy.
Uma chamada final é uma chamada de sub-rotina que acontece dentro de outro procedimento como seu final
Ação; pode produzir um valor de retorno que é imediatamente retornado pela chamada
procedimento. Se alguma chamada que uma sub-rotina executa, de modo que possa eventualmente levar
para esta mesma sub-rotina sendo chamada novamente na cadeia de chamada, está na posição final,
tal sub-rotina é considerada recursiva de cauda, ​​o que é um caso especial de recursão.
As chamadas finais são significativas porque podem ser implementadas sem adicionar uma nova pilha
quadro para a pilha de chamadas. A maior parte do quadro do procedimento atual não é necessária
mais, e pode ser substituído pelo quadro da chamada final. O programa pode então pular
para a sub-rotina chamada. Produzir esse código em vez de uma sequência de chamada padrão é
chamada eliminação da chamada final ou otimização da chamada final. A eliminação da chamada final permite
chamadas de procedimento na posição final sejam implementadas tão eficientemente quanto instruções goto,
permitindo assim uma programação estruturada eficiente. — Wikipédia (‐
http://en.wikipedia.org/wiki/Tail_call)

Macros
laço
laço estabelece um ponto de recursão. Com laço, recorrer religa as variáveis ​​definidas no
ponto de recursão e envia a execução do código de volta para esse ponto de recursão. Se recorrer é utilizado em
uma posição sem cauda, ​​uma exceção é lançada.

Uso: (ciclo ligações &descansar corpo)

Exemplo:

(requer hy.contrib.loop)

(definição fatorial [n]
(loop [[in] [acc 1]]
(se (zero? eu)
acc
(recorrente (dec i) (* acc i)))))

(fatorial 1000)

defmulti
Novo na versão 0.10.0.

defmulti permite sobrecarregar uma função com um determinado número de argumentos e/ou kwargs.
Inspirado na opinião de Clojure definir.

=> (requer hy.contrib.multi)
=> (defmulti divertido
... ([a] "a")
... ([ab] "ab")
... ([abc] "abc"))
=> (diversão 1)
"a"
=> (diversão 1 2)
"ab"
=> (divertido 1 2 3)
"abc"

HACKING ON HY

Cadastrar A Nossa Colmeia!
Por favor, venha hackear Hy!

Por favor, venha sair conosco #oi on irc.freenode.net!

Por favor, fale sobre isso no Twitter com o #oi hashtag!

Por favor, faça um blog sobre isso!

Por favor, não pinte com spray na cerca do seu vizinho (sem pedir com educação)!

Corte!
Faça isso:

1. Crie um virtual meio Ambiente:

$ virtualenv venv

e ative-o:

$. venv/bin/ativar

ou uso virtualenvwrapper para criar e gerenciar seu ambiente virtual:

$ mkvirtualenv por
$ trabalhando por aí

2. Obtenha o código-fonte:

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

ou use seu garfo:

$git clone [email protegido]: /hy.git

3. Instale para hackear:

$ cd hy/
$ pip instalar -e.

4. Instale outros requisitos de desenvolvimento:

$ pip install -r requisitos-dev.txt

5. Faça coisas incríveis; faça alguém gritar de alegria/nojo com o que você fez.

Teste!
Os testes estão localizados em testes /. Nós usamos nariz.

Para executar os testes:

$ testes de nariz

Escreva testes --- testes são bons!

Além disso, é bom executar os testes para todas as plataformas suportadas e compatíveis com PEP 8
código. Você pode fazer isso executando tox:

$ tóxico

Documento!
A documentação está localizada em docs /. Nós usamos Esfinge.

Para construir os documentos em HTML:

$cd documentos
$ fazer HTML

Escreva documentos --- documentos são bons! Até mesmo este documento!

Contribuindo
Contribuições são bem-vindas e muito apreciadas, cada pouquinho ajuda a tornar Hy mais
impressionante.

Solicitações pull são ótimas! Nós os amamos; aqui está um guia rápido:

· Bifurque o repositório e crie uma ramificação de tópico para um recurso/correção. Evite fazer alterações diretamente
no ramo mestre.

· Todos os recursos recebidos devem ser acompanhados de testes.

· Antes de enviar um PR, execute os testes e compare seu código com o estilo
guia. Você pode fazer as duas coisas ao mesmo tempo:

$ faça d

· Faça commits em unidades lógicas, para que seja mais fácil rastrear e navegar posteriormente. Antes
enviando um PR, tente compactar os commits em conjuntos de alterações que sejam fáceis de retornar
mais tarde. Além disso, certifique-se de não deixar espaços em branco falsos nos conjuntos de alterações; esse
evita a criação de commits de correção de espaços em branco posteriormente.

· No que diz respeito às mensagens de commit, tente seguir o seguinte:

· Tente manter o limite de 50 caracteres para a primeira linha das mensagens de commit do Git.

· Para mais detalhes/explicações, coloque uma linha em branco e continue
descrevendo o commit em detalhes.

· Finalmente, adicione-se ao arquivo AUTHORS (como um commit separado): você merece :)

· Todas as alterações recebidas precisam ser confirmadas por 2 membros diferentes da equipe principal da Hylang.
Revisão adicional é claramente bem-vinda, mas precisamos de um mínimo de 2 aprovações para qualquer
alterar.

· Se um membro principal estiver enviando um PR, encontre 2 membros principais que não incluam o
Remetente de relações públicas. A ideia aqui é que se possa trabalhar com o autor de relações públicas, e um segundo reconhece
todo o conjunto de alterações.

· Para documentação e outras alterações triviais, é bom mesclar após um ACK. Nós temos
baixa cobertura, então seria ótimo manter essa barreira baixa.

núcleo A Nossa Equipa
A equipe principal de desenvolvimento da Hy consiste nos seguintes desenvolvedores:

· Julien Danjou

· Morten Linderud

· J Kenneth Rei

· Gergely Nagy

· tuukka Turto

· Karen Rustad

· Abhishek L

· Christopher Allan Webber

· Konrad Hinsen

· Vontade Kahn Greene

· Paul Tagliamonte

· Nicolas Dandrimont

· Prumo Tolberto

· Berker Peksag

· Clinton N. Dreisbach

· ele semaj

Use hy online using onworks.net services