1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
---
language: hy
filename: learnhy-pt.hy
contributors:
- ["Abhishek L", "http://twitter.com/abhishekl"]
translators:
- ["Miguel Araújo", "https://github.com/miguelarauj1o"]
lang: pt-br
---
Hy é um dialeto de Lisp escrito sobre Python. Isto é possível convertendo
código Hy em árvore sintática abstrata Python (ast). Portanto, isto permite
Hy chamar código Python nativo e vice-versa.
```hylang
;; Isso dá uma introdução básica em Hy, como uma preliminar para o link abaixo
;; https://hylang.org/try-hy
;;
; Comentários em ponto-e-vírgula, como em outros Lisps
;; s-noções básicas de expressão
; programas Lisp são feitos de expressões simbólicas ou sexps que se assemelham
(some-function args)
; agora o essencial "Olá mundo"
(print "hello world")
;; Tipos de dados simples
; Todos os tipos de dados simples são exatamente semelhantes aos seus homólogos
; em Python que
42 ; => 42
3.14 ; => 3.14
True ; => True
4+10j ; => (4+10j) um número complexo
; Vamos começar com um pouco de aritmética muito simples
(+ 4 1) ;=> 5
; o operador é aplicado a todos os argumentos, como outros Lisps
(+ 4 1 2 3) ;=> 10
(- 2 1) ;=> 1
(* 4 2) ;=> 8
(/ 4 1) ;=> 4
(% 4 2) ;=> 0 o operador módulo
; exponenciação é representado pelo operador ** como Python
(** 3 2) ;=> 9
; formas aninhadas vão fazer a coisa esperada
(+ 2 (* 4 2)) ;=> 10
; também operadores lógicos e ou não e igual etc. faz como esperado
(= 5 4) ;=> False
(not (= 5 4)) ;=> True
;; variáveis
; variáveis são definidas usando SETV, nomes de variáveis podem usar utf-8, exceto
; for ()[]{}",'`;#|
(setv a 42)
(setv π 3.14159)
(def *foo* 42)
;; outros tipos de dados de armazenamento
; strings, lists, tuples & dicts
; estes são exatamente os mesmos tipos de armazenamento de Python
"hello world" ;=> "hello world"
; operações de string funcionam semelhante em Python
(+ "hello " "world") ;=> "hello world"
; Listas são criadas usando [], a indexação começa em 0
(setv mylist [1 2 3 4])
; tuplas são estruturas de dados imutáveis
(setv mytuple (, 1 2))
; dicionários são pares de valores-chave
(setv dict1 {"key1" 42 "key2" 21})
; :nome pode ser utilizado para definir palavras-chave em Hy que podem ser utilizados para as chaves
(setv dict2 {:key1 41 :key2 20})
; usar 'get' para obter o elemento em um índice/key
(get mylist 1) ;=> 2
(get dict1 "key1") ;=> 42
; Alternativamente, se foram utilizadas palavras-chave que podem ser chamadas diretamente
(:key1 dict2) ;=> 41
;; funções e outras estruturas de programa
; funções são definidas usando defn, o último sexp é devolvido por padrão
(defn greet [name]
"A simple greeting" ; uma docstring opcional
(print "hello " name))
(greet "bilbo") ;=> "hello bilbo"
; funções podem ter argumentos opcionais, bem como argumentos-chave
(defn foolists [arg1 &optional [arg2 2]]
[arg1 arg2])
(foolists 3) ;=> [3 2]
(foolists 10 3) ;=> [10 3]
; funções anônimas são criados usando construtores 'fn' ou 'lambda'
; que são semelhantes para 'defn'
(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
;; operações de sequência
; Hy tem algumas utils embutidas para operações de sequência, etc.
; recuperar o primeiro elemento usando 'first' ou 'car'
(setv mylist [1 2 3 4])
(setv mydict {"a" 1 "b" 2})
(first mylist) ;=> 1
; corte listas usando 'cut'
(cut mylist 1 3) ;=> [2 3]
; obter elementos de uma lista ou dict usando 'get'
(get mylist 1) ;=> 2
(get mydict "b") ;=> 2
; lista de indexação começa a partir de 0, igual em Python
; assoc pode definir elementos em chaves/índices
(assoc mylist 2 10) ; faz mylist [1 2 10 4]
(assoc mydict "c" 3) ; faz mydict {"a" 1 "b" 2 "c" 3}
; há toda uma série de outras funções essenciais que torna o trabalho com
; sequências uma diversão
;; Python interop
;; importação funciona exatamente como em Python
(import datetime)
(import functools [partial reduce]) ; importa fun1 e fun2 do module1
(import matplotlib.pyplot :as plt) ; fazendo uma importação em foo como em bar
; todos os métodos de Python embutidas etc. são acessíveis a partir Hy
; a.foo(arg) is called as (.foo a arg)
(.split (.strip "hello world ")) ;=> ["hello" "world"]
;; Condicionais
; (if condition (body-if-true) (body-if-false)
(if (= passcode "moria")
(print "welcome")
(print "Speak friend, and Enter!"))
; aninhe múltiplas cláusulas 'if else if' com cond
(cond
(= someval 42) (print "Life, universe and everything else!")
(> someval 42) (print "val too large")
(< someval 42) (print "val too small"))
; declarações de grupo com 'do', essas são executadas sequencialmente
; formas como defn tem um 'do' implícito
(do
(setv someval 10)
(print "someval is set to " someval)) ;=> 10
; criar ligações lexicais com 'let', todas as variáveis definidas desta forma
; tem escopo local
(let [[nemesis {"superman" "lex luther"
"sherlock" "moriarty"
"seinfeld" "newman"}]]
(for [(, h v) (.items nemesis)]
(print (.format "{0}'s nemesis was {1}" h v))))
;; classes
; classes são definidas da seguinte maneira
(defclass Wizard [object]
(defn __init__ [self spell]
(setv self.spell spell)) ; init a mágica attr
(defn get-spell [self]
self.spell))
```
### Outras Leituras
Este tutorial é apenas uma introdução básica para Hy/Lisp/Python.
Docs Hy: [https://hylang.org/hy/doc](https://hylang.org/hy/doc)
Repo Hy no GitHub: [https://github.com/hylang/hy](https://github.com/hylang/hy)
Acesso ao freenode irc com #hy, hashtag no twitter: #hylang
|
