Translates The REPL section

.gitignore

@@ -130,3 +130,6 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+# Jetbrains
+.idea/

workshops/pythonbrasil2021/CONTRIBUTING.md

@@ -18,8 +18,8 @@ para manter a compatibilidade com a versão mais recente do https://mybinder.org
 
 Você é mais que bem-vinda a sugerir melhorias ao tutorial.
 Pedimos apenas que que verifique se nenhum
-https://github.com/fluentpython/lispy/issues[issue] ou
-https://github.com/fluentpython/lispy/pulls[pull request]
+[issue](https://github.com/fluentpython/lispy/issues) ou
+[pull request](https://github.com/fluentpython/lispy/pulls)
 já tenha sido criado por outra pessoa com a mesma sugestão.
 Em caso afirmativo, veja se pode contribuir com ela.
 
@@ -28,8 +28,7 @@ indique sua intenção em um comentário na _issue_ escolhida.
 Dessa forma, outras pessoas saberão que tem alguém trabalhando nela.
 Caso tenha ficado perdido ou com dúvidas, peça ajuda. <!-- como? -->
 
-Caso seja algo novo, crie uma nova
-https://github.com/fluentpython/lispy/issues[issue].
+Caso seja algo novo, crie uma nova [issue](https://github.com/fluentpython/lispy/issues).
 
 O mesmo vale para typos (erros ortograficos).
 

workshops/pythonbrasil2021/GLOSSÁRIO.md

@@ -7,20 +7,25 @@ Termos do domínio de _linguagens de programação_ adotados nesta oficina.
 de uma forma conveniente para o trabalho do _interpretador_ ou _compilador_.
 Em Python uma AST pode ser construída com listas, dicionários, e/ou objetos aninhados.
 
-**compilador**: programa que lê código-fonte e gera códigos binários para processadores específicos, na forma de binários executáveis ou bibliotecas. Compiladores usam _AST_ como representação do programa; a construção do binário é guiada pela AST. Ver: _interpretador_.
+**Compilador**: programa que lê código-fonte e gera códigos binários para processadores específicos, na forma de binários executáveis ou bibliotecas. Compiladores usam _AST_ como representação do programa; a construção do binário é guiada pela AST. Ver: _interpretador_.
 
-**infixo**: símbolo que aparece entre duas expressões, por exemplo operadores aritméticos infixos: `a + b`. Ver: _prefixo_.
+**Fork**: Chamamos de fork um projeto git que foi derivado de outro projeto git, podemos encarar ele como uma cópia do projeto original onde podemos experimentar mudanças livremente.
 
-**interpretador**: programa que lê código-fonte e o executa em memória, sem gerar um binário para a máquina hospedeira. Alguns interpretadores executam o programa lendo a AST, outros utilizam a AST para gerar _bytecode_ para uma _máquina virtual_. Ver: _compilador_.
+**Infixo**: símbolo que aparece entre duas expressões, por exemplo operadores aritméticos infixos: `a + b`. Ver: _prefixo_.
 
-**parser**: função que recebe o código-fonte e devolve uma _AST_ formada por objetos da _linguagem hospedeira_.
+**Interpretador**: programa que lê código-fonte e o executa em memória, sem gerar um binário para a máquina hospedeira. Alguns interpretadores executam o programa lendo a AST, outros utilizam a AST para gerar _bytecode_ para uma _máquina virtual_. Ver: _compilador_.
+
+**Parser**: função que recebe o código-fonte e devolve uma _AST_ formada por objetos da _linguagem hospedeira_.
 Ex: `parse('(* 2 pi)')` resulta em `['*', 2, 'pi']`.
 Traduções: _analisador sintático_ ou _analisador_.
 
-**prefixo**: símbolo que antecede uma ou mais expressões, por exemplo o operador aritmético prefixo
+**Prefixo**: símbolo que antecede uma ou mais expressões, por exemplo o operador aritmético prefixo
 `+ a b c d` devolve a soma dos quatro valores.
 Em Scheme, expressões prefixas são delimitadas por parêntesis `(+ a b c d)`. Ver: _infixo_.
 
-**varíadico**: um parâmetro em uma função que aceita zero ou mais argumentos. Ex.: `def soma(*p): return sum(p)` cria uma função com o parâmetro variádico `p`, podendo ser usada como `soma()`, `soma(1, 2)`, ou `soma(1, 2, 3, 4)`, ou `soma(*range(1_000_000))`.
-Em Scheme, alguns operadores como `+`, `*`, `=`, `<` são variádicos: `(+ 1 2 3 4)`.
+**Prompt**: É um sinal gráfico que um programa mostra para o usuário para mostrar que está esperando uma entrada, podemos observar isso quando estamos no terminal e fica algo parecido com `|` piscando e aguardando um comando.
 
+**REPL**: REPL ou Read-Eval-Print-Loop é como podemos chamar um shell interativo onde a gente entra algum comando/expressão o programa interpreta aquilo, mostra o resultado e volta para o estado inicial esperando por novas entradas do usuário. Um grande exemplo disso é quando abrimos o shell do Python e ele fica com o prompt. `>>>`, esperando que digitemos alguma coisa.
+
+**Varíadico**: um parâmetro em uma função que aceita zero ou mais argumentos. Ex.: `def soma(*p): return sum(p)` cria uma função com o parâmetro variádico `p`, podendo ser usada como `soma()`, `soma(1, 2)`, ou `soma(1, 2, 3, 4)`, ou `soma(*range(1_000_000))`.
+Em Scheme, alguns operadores como `+`, `*`, `=`, `<` são variádicos: `(+ 1 2 3 4)`.

workshops/pythonbrasil2021/norvigs-lispy.py

@@ -35,7 +35,7 @@
 # * [Um ambiente mais completo](#Um-ambiente-mais-completo)
 # * [`Procedure`: a class to represent a closure](#Procedure:-a-class-to-represent-a-closure)
 # * [Evaluate with `lambda`, `if`, and `quote`](#Evaluate-with-lambda,-if,-and-quote)
-# * [The REPL](#The-REPL)
+# * [O REPL](#O-REPL)
 # * [Exemplos](#Exemplos)
 # * [Syntactic sugar](#Syntactic-sugar)
 #
@@ -744,21 +744,21 @@ def evaluate(x: Expression, env: Environment) -> Any:
 run(source)
 
 
-# ## The REPL
+# ## O REPL
 #
-# Norvig's REPL (Read-Eval-Print-Loop) is easy to undersand but not user-friendly.
-# If no command-line arguments are given to _lis.py_,
-# the `repl()` function is invoked by `main()`—defined at the end of the module.
-# At the `lis.py>` prompt we must enter correct and complete expressions—if
-# we forget to close one parenthesis, _lis.py_ crashes.
+# O REPL (Read-Eval-Print-Loop) feito pelo Norvig é fácil de entender porém não é
+# muito amigavél. Se nenhum argumento é passado na linha de comando para o _lisp.py_,
+# a função `repl()` é invocada pela função `main()` definida no final do módulo.
+# Um prompt irá aparecer `lis.py>`, nele devemos digitar as expressões corretamente e completas, se esquecermos de
+# fechar um paretenses o _lis.py_ irá quebrar.
 #
-# > **NOTE**: As I studied Norvig's _lis.py_ and _lispy.py_, I started a fork named
-#   [`mylis`](https://github.com/fluentpython/lispy/blob/main/mylis)
-#   which adds some features, including a REPL that accepts partial S-expressions
-#   and prompts for the continuation, similar to how Python's REPL
-#   knows we are not finished and presents the secondary prompt `...` until
-#   we enter a complete expression or statement that can be evaluated.
-#   `mylis` also handles a few errors gracefully, but it's still easy to crash.
+# > **NOTA**: Como eu estudei os dois scripts feitos pelo Norvig, _lis.py_ e _lispy.py_,
+#   criei um fork chamado [`mylis`](https://github.com/fluentpython/lispy/blob/main/mylis)
+#   com algumas funcionalidades a mais, como um REPL que aceita expressões parciais que podem
+#   ser continuadas nas próximas linhas, similar como o REPL do Python sabe que não terminamos
+#   e nos apresenta um segundo prompt `...` até que entremos um expressão ou statement completo
+#   que possa ser interpretado.
+#   `mylis` também consegue tratar alguns erros para evitar falhas porém ainda é fácil de quebrar.
 #
 
 # +
@@ -781,17 +781,17 @@ def lispstr(exp: object) -> str:
 
 # -
 
-# Function `repl` calls `standard_env()` to provide built-in functions for the global environment,
-# then enters an infinite loop reading and parsing each input line,
-# evaluating it in the global environment and displaying the result—unless it's `None`.
-# The `global_env` may be modified by `evaluate`.
+# A função `repl` chama a função `standard_env()` para que funções built-in fiquem disponíveis
+# no escopo global, então entra em um loop infinito lendo e fazendo o parse de cada linha entrada
+# pelo usuário, depois interpreta essas linhas no escopo global mostrando o resultado a menos que ele seja `None`.
+# A variável `global_env` pode ser modificada pelo `evaluate`.
 #
-# `lispstr` is the inverse function of `parse`:
-# given a Python object representing an expression,
-# `parse` returns the Scheme source code for it.
-# For example:
+# A função `lispstr` faz o inverso da função `parse`:
+#
+# Dado um objeto Python que representa uma expressão, `lispstr` retorna o código em Scheme para ela.
+# Por exemplo:
 
-lispstr(['+', 32, ['*', ['/', 9, 5], 'c']])
+lispstr(['+', 32, ['*', ['/', 9, 5], 'c']])  # Irá retornar: '(+ 32 (* (/ 9 5) c))'
 
 # ## Exemplos
 #