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
|
---
language: factor
contributors:
- ["hyphz", "http://github.com/hyphz/"]
filename: learnfactor.factor
lang: pt-br
---
Factor é uma linguagem moderna baseada em pilha, baseado em Forth, criada por Slava Pestov.
Código neste arquivo pode ser digitado em Fator, mas não importado diretamente porque o cabeçalho de vocabulário e importação faria o início completamente confuso.
```factor
! Este é um comentário
! Como Forth, toda a programação é feita manipulando a pilha.
! A indicação de um valor literal o coloca na pilha.
5 2 3 56 76 23 65 ! Nenhuma saída, mas a pilha é impressa no modo interativo
! Esses números são adicionados à pilha, da esquerda para a direita.
! .s imprime a pilha de forma não destrutiva.
.s ! 5 2 3 56 76 23 65
! A aritmética funciona manipulando dados na pilha.
5 4 + ! Sem saída
! `.` mostra o resultado superior da pilha e o imprime.
. ! 9
! Mais exemplos de aritmética:
6 7 * . ! 42
1360 23 - . ! 1337
12 12 / . ! 1
13 2 mod . ! 1
99 neg . ! -99
-99 abs . ! 99
52 23 max . ! 52
52 23 min . ! 23
! Várias palavras são fornecidas para manipular a pilha, coletivamente conhecidas como palavras embaralhadas.
3 dup - ! duplica o primeiro item (1st agora igual a 2nd): 3 - 3
2 5 swap / ! troca o primeiro com o segundo elemento: 5 / 2
4 0 drop 2 / ! remove o primeiro item (não imprima na tela): 4 / 2
1 2 3 nip .s ! remove o segundo item (semelhante a drop): 1 3
1 2 clear .s ! acaba com toda a pilha
1 2 3 4 over .s ! duplica o segundo item para o topo: 1 2 3 4 3
1 2 3 4 2 pick .s ! duplica o terceiro item para o topo: 1 2 3 4 2 3
! Criando Palavras
! O `:` conjuntos de palavras do Factor no modo de compilação até que ela veja a palavra `;`.
: square ( n -- n ) dup * ; ! Sem saída
5 square . ! 25
! Podemos ver o que as palavra fazem também.
! \ suprime a avaliação de uma palavra e coloca seu identificador na pilha.
\ square see ! : square ( n -- n ) dup * ;
! Após o nome da palavra para criar, a declaração entre parênteses dá o efeito da pilha.
! Podemos usar os nomes que quisermos dentro da declaração:
: weirdsquare ( camel -- llama ) dup * ;
! Contanto que sua contagem corresponda ao efeito da pilha da palavra:
: doubledup ( a -- b ) dup dup ; ! Error: Stack effect declaration is wrong
: doubledup ( a -- a a a ) dup dup ; ! Ok
: weirddoubledup ( i -- am a fish ) dup dup ; ! Além disso Ok
! Onde Factor difere do Forth é no uso de citações.
! Uma citação é um bloco de código que é colocado na pilha como um valor.
! [ inicia o modo de citação; ] termina.
[ 2 + ] ! A citação que adiciona 2 é deixada na pilha
4 swap call . ! 6
! E assim, palavras de ordem mais alta. TONS de palavras de ordem superior.
2 3 [ 2 + ] dip .s ! Retira valor do topo da pilha, execute citação, empurre de volta: 4 3
3 4 [ + ] keep .s ! Copie o valor do topo da pilha, execute a citação, envie a cópia: 7 4
1 [ 2 + ] [ 3 + ] bi .s ! Executar cada citação no valor do topo, empurrar os dois resultados: 3 4
4 3 1 [ + ] [ + ] bi .s ! As citações em um bi podem extrair valores mais profundos da pilha: 4 5 ( 1+3 1+4 )
1 2 [ 2 + ] bi@ .s ! Executar a citação no primeiro e segundo valores
2 [ + ] curry ! Injeta o valor fornecido no início da citação: [ 2 + ] é deixado na pilha
! Condicionais
! Qualquer valor é verdadeiro, exceto o valor interno f.
! m valor interno não existe, mas seu uso não é essencial.
! Condicionais são palavras de maior ordem, como com os combinadores acima.
5 [ "Five is true" . ] when ! Cinco é verdadeiro
0 [ "Zero is true" . ] when ! Zero é verdadeiro
f [ "F is true" . ] when ! Sem saída
f [ "F is false" . ] unless ! F é falso
2 [ "Two is true" . ] [ "Two is false" . ] if ! Two é verdadeiro
! Por padrão, as condicionais consomem o valor em teste, mas variantes com asterisco
! deixe sozinho se é verdadeiro:
5 [ . ] when* ! 5
f [ . ] when* ! Nenhuma saída, pilha vazia, f é consumida porque é falsa
! Laços
! Você adivinhou .. estas são palavras de ordem mais elevada também.
5 [ . ] each-integer ! 0 1 2 3 4
4 3 2 1 0 5 [ + . ] each-integer ! 0 2 4 6 8
5 [ "Hello" . ] times ! Hello Hello Hello Hello Hello
! Here's a list:
{ 2 4 6 8 } ! Goes on the stack as one item
! Aqui está uma lista:
{ 2 4 6 8 } [ 1 + . ] each ! Exibe 3 5 7 9
{ 2 4 6 8 } [ 1 + ] map ! Sai { 3 5 7 9 } na pilha
! Reduzir laços ou criar listas:
{ 1 2 3 4 5 } [ 2 mod 0 = ] filter ! Mantém apenas membros da lista para os quais a citação é verdadeira: { 2 4 }
{ 2 4 6 8 } 0 [ + ] reduce . ! Como "fold" em linguagens funcionais: exibe 20 (0+2+4+6+8)
{ 2 4 6 8 } 0 [ + ] accumulate . . ! Como reduzir, mas mantém os valores intermediários em uma lista: exibe { 0 2 6 12 } então 20
1 5 [ 2 * dup ] replicate . ! Repete a citação 5 vezes e coleta os resultados em uma lista: { 2 4 8 16 32 }
1 [ dup 100 < ] [ 2 * dup ] produce ! Repete a segunda citação até que a primeira retorne como falsa e colete os resultados: { 2 4 8 16 32 64 128 }
! Se tudo mais falhar, uma finalidade geral, enquanto repete:
1 [ dup 10 < ] [ "Hello" . 1 + ] while ! Exibe "Hello" 10 vezes
! Sim, é difícil de ler
! Isso é o que todos esses loops variantes são para
! Variáveis
! Normalmente, espera-se que os programas Factor mantenham todos os dados na pilha.
! Usar variáveis nomeadas torna a refatoração mais difícil (e é chamada de Factor por um motivo)
! Variáveis globais, se você precisar:
SYMBOL: name ! Cria o nome como uma palavra identificadora
"Bob" name set-global ! Sem saída
name get-global . ! "Bob"
! Variáveis locais nomeadas são consideradas uma extensão, mas estão disponíveis
! Em uma citação ..
[| m n ! A citação captura os dois principais valores da pilha em m e n
| m n + ] ! Leia-os
! Ou em uma palavra..
:: lword ( -- ) ! Note os dois pontos duplos para invocar a extensão da variável lexica
2 :> c ! Declara a variável imutável c para manter 2
c . ; ! Imprima isso
! Em uma palavra declarada dessa maneira, o lado de entrada da declaração de pilha
! torna-se significativo e fornece os valores das variáveis em que os valores da pilha são capturados
:: double ( a -- result ) a 2 * ;
! Variáveis são declaradas mutáveis ao terminar seu nome com um ponto de exclamação
:: mword2 ( a! -- x y ) ! Capture o topo da pilha na variável mutável a
a ! Empurrar a
a 2 * a! ! Multiplique por 2 e armazene o resultado em a
a ; ! Empurre novo valor de a
5 mword2 ! Pilha: 5 10
! Listas e Sequências
! Vimos acima como empurrar uma lista para a pilha
0 { 1 2 3 4 } nth ! Acessar um membro específico de uma lista: 1
10 { 1 2 3 4 } nth ! Error: índice de sequência fora dos limites
1 { 1 2 3 4 } ?nth ! O mesmo que nth se o índice estiver dentro dos limites: 2
10 { 1 2 3 4 } ?nth ! Nenhum erro se estiver fora dos limites: f
{ "at" "the" "beginning" } "Append" prefix ! { "Append" "at" "the" "beginning" }
{ "Append" "at" "the" } "end" suffix ! { "Append" "at" "the" "end" }
"in" 1 { "Insert" "the" "middle" } insert-nth ! { "Insert" "in" "the" "middle" }
"Concat" "enate" append ! "Concatenate" - strings are sequences too
"Concatenate" "Reverse " prepend ! "Reverse Concatenate"
{ "Concatenate " "seq " "of " "seqs" } concat ! "Concatenate seq of seqs"
{ "Connect" "subseqs" "with" "separators" } " " join ! "Connect subseqs with separators"
! E se você quiser obter meta, as citações são seqüências e podem ser desmontadas..
0 [ 2 + ] nth ! 2
1 [ 2 + ] nth ! +
[ 2 + ] \ - suffix ! Quotation [ 2 + - ]
```
##Pronto para mais?
* [Documentação do Factor](http://docs.factorcode.org/content/article-help.home.html)
|
