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
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
---
language: Paren
filename: learnparen-pt.paren
contributors:
- ["KIM Taegyoon", "https://github.com/kimtg"]
translators:
- ["Claudson Martins", "https://github.com/claudsonm"]
lang: pt-br
---
[Paren](https://bitbucket.org/ktg/paren) é um dialeto do Lisp. É projetado para ser uma linguagem embutida.
Alguns exemplos foram retirados de <http://learnxinyminutes.com/docs/racket/>.
```scheme
;;; Comentários
# Comentários
;; Comentários de única linha começam com um ponto e vírgula ou cerquilha
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 1. Tipos de Dados Primitivos e Operadores
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Números
123 ; inteiro
3.14 ; double
6.02e+23 ; double
(int 3.14) ; => 3 : inteiro
(double 123) ; => 123 : double
;; O uso de funções é feito da seguinte maneira (f x y z ...)
;; onde f é uma função e x, y, z, ... são os operandos
;; Se você quiser criar uma lista literal de dados, use (quote) para impedir
;; que sejam interpretados
(quote (+ 1 2)) ; => (+ 1 2)
;; Agora, algumas operações aritméticas
(+ 1 1) ; => 2
(- 8 1) ; => 7
(* 10 2) ; => 20
(^ 2 3) ; => 8
(/ 5 2) ; => 2
(% 5 2) ; => 1
(/ 5.0 2) ; => 2.5
;;; Booleanos
true ; para verdadeiro
false ; para falso
(! true) ; => falso
(&& true false (prn "não chega aqui")) ; => falso
(|| false true (prn "não chega aqui")) ; => verdadeiro
;;; Caracteres são inteiros.
(char-at "A" 0) ; => 65
(chr 65) ; => "A"
;;; Strings são arrays de caracteres de tamanho fixo.
"Olá, mundo!"
"Sebastião \"Tim\" Maia" ; Contra-barra é um caractere de escape
"Foo\tbar\r\n" ; Inclui os escapes da linguagem C: \t \r \n
;; Strings podem ser concatenadas também!
(strcat "Olá " "mundo!") ; => "Olá mundo!"
;; Uma string pode ser tratada como uma lista de caracteres
(char-at "Abacaxi" 0) ; => 65
;; A impressão é muito fácil
(pr "Isso é" "Paren. ") (prn "Prazer em conhecê-lo!")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 2. Variáveis
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Você pode criar ou definir uma variável usando (set)
;; o nome de uma variável pode conter qualquer caracter, exceto: ();#"
(set alguma-variavel 5) ; => 5
alguma-variavel ; => 5
;; Acessar uma variável ainda não atribuída gera uma exceção
; x ; => Unknown variable: x : nil
;; Ligações locais: Utiliza cálculo lambda!
;; 'a' e 'b' estão ligados a '1' e '2' apenas dentro de (fn ...)
((fn (a b) (+ a b)) 1 2) ; => 3
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 3. Coleções
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Listas
;; Listas são estruturas de dados semelhantes a vetores. (A classe de comportamento é O(1).)
(cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3)
;; 'list' é uma variação conveniente para construir listas
(list 1 2 3) ; => (1 2 3)
;; Um quote também pode ser usado para uma lista de valores literais
(quote (+ 1 2)) ; => (+ 1 2)
;; Você ainda pode utilizar 'cons' para adicionar um item ao início da lista
(cons 0 (list 1 2 3)) ; => (0 1 2 3)
;; Listas são um tipo muito básico, portanto existe *enorme* funcionalidade
;; para elas, veja alguns exemplos:
(map inc (list 1 2 3)) ; => (2 3 4)
(filter (fn (x) (== 0 (% x 2))) (list 1 2 3 4)) ; => (2 4)
(length (list 1 2 3 4)) ; => 4
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 3. Funções
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Use 'fn' para criar funções.
;; Uma função sempre retorna o valor de sua última expressão
(fn () "Olá Mundo") ; => (fn () Olá Mundo) : fn
;; Use parênteses para chamar todas as funções, incluindo uma expressão lambda
((fn () "Olá Mundo")) ; => "Olá Mundo"
;; Atribuir uma função a uma variável
(set ola-mundo (fn () "Olá Mundo"))
(ola-mundo) ; => "Olá Mundo"
;; Você pode encurtar isso utilizando a definição de função açúcar sintático:
(defn ola-mundo2 () "Olá Mundo")
;; Os () acima é a lista de argumentos para a função
(set ola
(fn (nome)
(strcat "Olá " nome)))
(ola "Steve") ; => "Olá Steve"
;; ... ou equivalente, usando a definição açucarada:
(defn ola2 (nome)
(strcat "Olá " name))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 4. Igualdade
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Para números utilize '=='
(== 3 3.0) ; => verdadeiro
(== 2 1) ; => falso
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 5. Controle de Fluxo
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Condicionais
(if true ; Testa a expressão
"isso é verdade" ; Então expressão
"isso é falso") ; Senão expressão
; => "isso é verdade"
;;; Laços de Repetição
;; O laço for é para número
;; (for SÍMBOLO INÍCIO FIM SALTO EXPRESSÃO ..)
(for i 0 10 2 (pr i "")) ; => Imprime 0 2 4 6 8 10
(for i 0.0 10 2.5 (pr i "")) ; => Imprime 0 2.5 5 7.5 10
;; Laço while
((fn (i)
(while (< i 10)
(pr i)
(++ i))) 0) ; => Imprime 0123456789
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 6. Mutação
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Use 'set' para atribuir um novo valor a uma variável ou local
(set n 5) ; => 5
(set n (inc n)) ; => 6
n ; => 6
(set a (list 1 2)) ; => (1 2)
(set (nth 0 a) 3) ; => 3
a ; => (3 2)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; 7. Macros
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Macros lhe permitem estender a sintaxe da linguagem.
;; As macros no Paren são fáceis.
;; Na verdade, (defn) é uma macro.
(defmacro setfn (nome ...) (set nome (fn ...)))
(defmacro defn (nome ...) (def nome (fn ...)))
;; Vamos adicionar uma notação infixa
(defmacro infix (a op ...) (op a ...))
(infix 1 + 2 (infix 3 * 4)) ; => 15
;; Macros não são higiênicas, você pode sobrescrever as variáveis já existentes!
;; Elas são transformações de códigos.
```
|
