From 401093269d1a5b0db14c54f2e355ff3461b43325 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Tue, 20 Oct 2015 23:53:25 -0200
Subject: Pogoscript to pt-br

Partial translation to pt-br
---
 pt-br/pogo.html.markdown | 202 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 202 insertions(+)
 create mode 100644 pt-br/pogo.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/pogo.html.markdown b/pt-br/pogo.html.markdown
new file mode 100644
index 00000000..80972c98
--- /dev/null
+++ b/pt-br/pogo.html.markdown
@@ -0,0 +1,202 @@
+---
+language: pogoscript
+contributors:
+    - ["Tim Macfarlane", "http://github.com/refractalize"]
+    - ["Cássio Böck", "https://github.com/cassiobsilva"]
+filename: learnPogo.pogo
+---
+
+Pogoscript é uma linguagem de programação que possui tipos primitivos concorrents
+e que compila para linguagem Javascript padrão.
+
+``` javascript
+// definindo uma variável
+water temperature = 24
+
+// reatribuindo o valor de uma variável após a sua definição
+water temperature := 26
+
+// funções permitem que seus parâmetros sejam colocados em qualquer lugar
+temperature at (a) altitude = 32 - a / 100
+
+// funções longas são apenas indentadas
+temperature at (a) altitude :=
+    if (a < 0)
+        water temperature
+    else
+        32 - a / 100
+
+// chamada de uma função
+current temperature = temperature at 3200 altitude
+
+// essa função cria um novo objeto com métodos
+position (x, y) = {
+    x = x
+    y = y
+
+    distance from position (p) =
+        dx = self.x - p.x
+        dy = self.y - p.y
+        Math.sqrt (dx * dx + dy * dy)
+}
+
+// `self` é similiar ao `this` no Javascript, com exceção de que `self` não
+// é redefinido em cada nova função
+
+// chamada de métodos
+position (7, 2).distance from position (position (5, 1))
+
+// assim como no Javascript, objetos também são hashes
+position.'x' == position.x == position.('x')
+
+// arrays
+positions = [
+    position (1, 1)
+    position (1, 2)
+    position (1, 3)
+]
+
+// indexando um array
+positions.0.y
+
+n = 2
+positions.(n).y
+
+// strings
+poem = 'Tail turned to red sunset on a juniper crown a lone magpie cawks.
+        Mad at Oryoki in the shrine-room -- Thistles blossomed late afternoon.
+        Put on my shirt and took it off in the sun walking the path to lunch.
+        A dandelion seed floats above the marsh grass with the mosquitos.
+        At 4 A.M. the two middleaged men sleeping together holding hands.
+        In the half-light of dawn a few birds warble under the Pleiades.
+        Sky reddens behind fir trees, larks twitter, sparrows cheep cheep cheep
+        cheep cheep.'
+
+// texto de Allen Ginsburg
+
+// interpolação
+outlook = 'amazing!'
+console.log "the weather tomorrow is going to be #(outlook)"
+
+// expressões regulares
+r/(\d+)m/i
+r/(\d+) degrees/mg
+
+// operadores
+true @and true
+false @or true
+@not false
+2 < 4
+2 >= 2
+2 > 1
+
+// todos do Javascript também são suportados
+
+// definindo seu próprio operador
+(p1) plus (p2) =
+    position (p1.x + p2.x, p1.y + p2.y)
+
+// `plus` pode ser usado com um operador
+position (1, 1) @plus position (0, 2)
+// ou como uma função
+(position (1, 1)) plus (position (0, 2))
+
+// retorno explícito
+(x) times (y) = return (x * y)
+
+// new
+now = @new Date ()
+
+// funções podem receber argumentos opcionais
+spark (position, color: 'black', velocity: {x = 0, y = 0}) = {
+    color = color
+    position = position
+    velocity = velocity
+}
+
+red = spark (position 1 1, color: 'red')
+fast black = spark (position 1 1, velocity: {x = 10, y = 0})
+
+// functions can unsplat arguments too
+log (messages, ...) =
+    console.log (messages, ...)
+
+// blocks are functions passed to other functions.
+// This block takes two parameters, `spark` and `c`,
+// the body of the block is the indented code after the
+// function call
+
+render each @(spark) into canvas context @(c)
+    ctx.begin path ()
+    ctx.stroke style = spark.color
+    ctx.arc (
+        spark.position.x + canvas.width / 2
+        spark.position.y
+        3
+        0
+        Math.PI * 2
+    )
+    ctx.stroke ()
+
+// asynchronous calls
+
+// JavaScript both in the browser and on the server (with Node.js)
+// makes heavy use of asynchronous IO with callbacks. Async IO is
+// amazing for performance and making concurrency simple but it
+// quickly gets complicated.
+// Pogoscript has a few things to make async IO much much easier
+
+// Node.js includes the `fs` module for accessing the file system.
+// Let's list the contents of a directory
+
+fs = require 'fs'
+directory listing = fs.readdir! '.'
+
+// `fs.readdir()` is an asynchronous function, so we can call it
+// using the `!` operator. The `!` operator allows you to call
+// async functions with the same syntax and largely the same
+// semantics as normal synchronous functions. Pogoscript rewrites
+// it so that all subsequent code is placed in the callback function
+// to `fs.readdir()`.
+
+// to catch asynchronous errors while calling asynchronous functions
+
+try
+    another directory listing = fs.readdir! 'a-missing-dir'
+catch (ex)
+    console.log (ex)
+
+// in fact, if you don't use `try catch`, it will raise the error up the
+// stack to the outer-most `try catch` or to the event loop, as you'd expect
+// with non-async exceptions
+
+// all the other control structures work with asynchronous calls too
+// here's `if else`
+config =
+    if (fs.stat! 'config.json'.is file ())
+        JSON.parse (fs.read file! 'config.json' 'utf-8')
+    else
+        {
+            color: 'red'
+        }
+
+// to run two asynchronous calls concurrently, use the `?` operator.
+// The `?` operator returns a *future* which can be executed to
+// wait for and obtain the result, again using the `!` operator
+
+// we don't wait for either of these calls to finish
+a = fs.stat? 'a.txt'
+b = fs.stat? 'b.txt'
+
+// now we wait for the calls to finish and print the results
+console.log "size of a.txt is #(a!.size)"
+console.log "size of b.txt is #(b!.size)"
+
+// futures in Pogoscript are analogous to Promises
+```
+
+That's it.
+
+Download [Node.js](http://nodejs.org/) and `npm install pogo`.
+
+There is plenty of documentation on [http://pogoscript.org/](http://pogoscript.org/), including a [cheat sheet](http://pogoscript.org/cheatsheet.html), a [guide](http://pogoscript.org/guide/), and how [Pogoscript translates to Javascript](http://featurist.github.io/pogo-examples/). Get in touch on the [google group](http://groups.google.com/group/pogoscript) if you have questions!
-- 
cgit v1.2.3


From f0daae643482918fce3c75b012087dc19f883d25 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Wed, 21 Oct 2015 23:30:42 -0200
Subject: translation to pt-br

translation to pt-br completed
---
 pt-br/pogo.html.markdown | 76 ++++++++++++++++++++++++------------------------
 1 file changed, 38 insertions(+), 38 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/pogo.html.markdown b/pt-br/pogo.html.markdown
index 80972c98..5dc81ec0 100644
--- a/pt-br/pogo.html.markdown
+++ b/pt-br/pogo.html.markdown
@@ -3,7 +3,8 @@ language: pogoscript
 contributors:
     - ["Tim Macfarlane", "http://github.com/refractalize"]
     - ["Cássio Böck", "https://github.com/cassiobsilva"]
-filename: learnPogo.pogo
+filename: learnPogo-pt-br.pogo
+lang: pt-br
 ---
 
 Pogoscript é uma linguagem de programação que possui tipos primitivos concorrents
@@ -26,7 +27,7 @@ temperature at (a) altitude :=
     else
         32 - a / 100
 
-// chamada de uma função
+// declarando uma função
 current temperature = temperature at 3200 altitude
 
 // essa função cria um novo objeto com métodos
@@ -43,7 +44,7 @@ position (x, y) = {
 // `self` é similiar ao `this` no Javascript, com exceção de que `self` não
 // é redefinido em cada nova função
 
-// chamada de métodos
+// declaração de métodos
 position (7, 2).distance from position (position (5, 1))
 
 // assim como no Javascript, objetos também são hashes
@@ -117,14 +118,13 @@ spark (position, color: 'black', velocity: {x = 0, y = 0}) = {
 red = spark (position 1 1, color: 'red')
 fast black = spark (position 1 1, velocity: {x = 10, y = 0})
 
-// functions can unsplat arguments too
+// funções também podem ser utilizadas para realizar o "unsplat" de argumentos
 log (messages, ...) =
     console.log (messages, ...)
 
-// blocks are functions passed to other functions.
-// This block takes two parameters, `spark` and `c`,
-// the body of the block is the indented code after the
-// function call
+// blocos são funções passadas para outras funções.
+// Este bloco recebe dois parâmetros, `spark` e `c`,
+// o corpo do bloco é o código indentado após a declaração da função
 
 render each @(spark) into canvas context @(c)
     ctx.begin path ()
@@ -138,40 +138,40 @@ render each @(spark) into canvas context @(c)
     )
     ctx.stroke ()
 
-// asynchronous calls
+// chamadas assíncronas
 
-// JavaScript both in the browser and on the server (with Node.js)
-// makes heavy use of asynchronous IO with callbacks. Async IO is
-// amazing for performance and making concurrency simple but it
-// quickly gets complicated.
-// Pogoscript has a few things to make async IO much much easier
+// O Javascript, tanto no navegador quanto no servidor (através do Node.js)
+// realiza um uso massivo de funções assíncronas de E/S (entrada/saída) com
+// chamadas de retorno. E/S assíncrona é maravilhosa para a performance e
+// torna a concorrência simples, porém pode rapidamente se tornar algo complicado.
+// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono mosquitos
+// mais fácil
 
-// Node.js includes the `fs` module for accessing the file system.
-// Let's list the contents of a directory
+// O Node.js inclui o móduolo `fs` para acessar o sistema de arquivos.
+// Vamos listar o conteúdo de um diretório
 
 fs = require 'fs'
 directory listing = fs.readdir! '.'
 
-// `fs.readdir()` is an asynchronous function, so we can call it
-// using the `!` operator. The `!` operator allows you to call
-// async functions with the same syntax and largely the same
-// semantics as normal synchronous functions. Pogoscript rewrites
-// it so that all subsequent code is placed in the callback function
-// to `fs.readdir()`.
+// `fs.readdir()` é uma função assíncrona, então nos a chamamos usando o
+// operador `!`. O operador `!` permite que você chame funções assíncronas
+// com a mesma sintaxe e praticamente a mesma semântica do que as demais
+// funções síncronas. O Pogoscript reescreve a função para que todo código
+// inserido após o operador seja inserido em uma função de callback para o
+// `fs.readdir()`.
 
-// to catch asynchronous errors while calling asynchronous functions
+// para se obter erros ao utilizar funções assíncronas
 
 try
     another directory listing = fs.readdir! 'a-missing-dir'
 catch (ex)
     console.log (ex)
 
-// in fact, if you don't use `try catch`, it will raise the error up the
-// stack to the outer-most `try catch` or to the event loop, as you'd expect
-// with non-async exceptions
+// na verdade, se você não usar o `try catch`, o erro será passado para o
+// `try catch` mais externo do evento, assim como é feito nas exceções síncronas
 
-// all the other control structures work with asynchronous calls too
-// here's `if else`
+// todo o controle de estrutura funciona com chamadas assíncronas também
+// aqui um exemplo de `if else`
 config =
     if (fs.stat! 'config.json'.is file ())
         JSON.parse (fs.read file! 'config.json' 'utf-8')
@@ -180,23 +180,23 @@ config =
             color: 'red'
         }
 
-// to run two asynchronous calls concurrently, use the `?` operator.
-// The `?` operator returns a *future* which can be executed to
-// wait for and obtain the result, again using the `!` operator
+// para executar duas chamadas assíncronas de forma concorrente, use o
+// operador `?`.
+// O operador `?` retorna um *future* que pode ser executado aguardando
+// o resultado, novamente utilizando o operador `o`
 
-// we don't wait for either of these calls to finish
+// nós não esperamos nenhuma dessas chamadas serem concluídas
 a = fs.stat? 'a.txt'
 b = fs.stat? 'b.txt'
 
-// now we wait for the calls to finish and print the results
+// agora nos aguardamos o término das chamadas e escrevemos os resultados
 console.log "size of a.txt is #(a!.size)"
 console.log "size of b.txt is #(b!.size)"
 
-// futures in Pogoscript are analogous to Promises
+// no Pogoscript, futures são semelhantes a Promises
 ```
+E encerramos por aqui.
 
-That's it.
+Baixe o [Node.js](http://nodejs.org/) e execute `npm install pogo`.
 
-Download [Node.js](http://nodejs.org/) and `npm install pogo`.
-
-There is plenty of documentation on [http://pogoscript.org/](http://pogoscript.org/), including a [cheat sheet](http://pogoscript.org/cheatsheet.html), a [guide](http://pogoscript.org/guide/), and how [Pogoscript translates to Javascript](http://featurist.github.io/pogo-examples/). Get in touch on the [google group](http://groups.google.com/group/pogoscript) if you have questions!
+Há bastante documentação em [http://pogoscript.org/](http://pogoscript.org/), incluindo um material para [consulta rápida](http://pogoscript.org/cheatsheet.html), um [guia](http://pogoscript.org/guide/), e como o [Pogoscript é traduzido para o Javascript](http://featurist.github.io/pogo-examples/). Entre em contato através do [grupo do Google](http://groups.google.com/group/pogoscript) se você possui dúvidas!
-- 
cgit v1.2.3


From 4c9f38665d291e4abe2c7d57e633f5aed9eb72ae Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Thu, 22 Oct 2015 00:35:27 -0200
Subject: grammar fixes

Portuguese changes to a better text understanding
---
 pt-br/pogo.html.markdown | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

(limited to 'pt-br')

diff --git a/pt-br/pogo.html.markdown b/pt-br/pogo.html.markdown
index 5dc81ec0..124b32f7 100644
--- a/pt-br/pogo.html.markdown
+++ b/pt-br/pogo.html.markdown
@@ -41,7 +41,7 @@ position (x, y) = {
         Math.sqrt (dx * dx + dy * dy)
 }
 
-// `self` é similiar ao `this` no Javascript, com exceção de que `self` não
+// `self` é similiar ao `this` do Javascript, com exceção de que `self` não
 // é redefinido em cada nova função
 
 // declaração de métodos
@@ -91,7 +91,7 @@ false @or true
 2 >= 2
 2 > 1
 
-// todos do Javascript também são suportados
+// os operadores padrão do Javascript também são suportados
 
 // definindo seu próprio operador
 (p1) plus (p2) =
@@ -142,9 +142,10 @@ render each @(spark) into canvas context @(c)
 
 // O Javascript, tanto no navegador quanto no servidor (através do Node.js)
 // realiza um uso massivo de funções assíncronas de E/S (entrada/saída) com
-// chamadas de retorno. E/S assíncrona é maravilhosa para a performance e
-// torna a concorrência simples, porém pode rapidamente se tornar algo complicado.
-// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono mosquitos
+// chamadas de retorno (callbacks). A E/S assíncrona é ótima para a performance e
+// torna a utilização da concorrência simples, porém pode rapidamente se tornar
+// algo complicado.
+// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono muito
 // mais fácil
 
 // O Node.js inclui o móduolo `fs` para acessar o sistema de arquivos.
@@ -155,12 +156,11 @@ directory listing = fs.readdir! '.'
 
 // `fs.readdir()` é uma função assíncrona, então nos a chamamos usando o
 // operador `!`. O operador `!` permite que você chame funções assíncronas
-// com a mesma sintaxe e praticamente a mesma semântica do que as demais
-// funções síncronas. O Pogoscript reescreve a função para que todo código
-// inserido após o operador seja inserido em uma função de callback para o
-// `fs.readdir()`.
+// com a mesma sintaxe e a mesma semântica do que as demais funções síncronas.
+// O Pogoscript reescreve a função para que todo código inserido após o
+//  operador seja inserido em uma função de callback para o `fs.readdir()`.
 
-// para se obter erros ao utilizar funções assíncronas
+// obtendo erros ao utilizar funções assíncronas
 
 try
     another directory listing = fs.readdir! 'a-missing-dir'
@@ -168,9 +168,9 @@ catch (ex)
     console.log (ex)
 
 // na verdade, se você não usar o `try catch`, o erro será passado para o
-// `try catch` mais externo do evento, assim como é feito nas exceções síncronas
+// `try catch` mais externo do evento, assim como é feito em exceções síncronas
 
-// todo o controle de estrutura funciona com chamadas assíncronas também
+// todo o controle de estrutura também funciona com chamadas assíncronas
 // aqui um exemplo de `if else`
 config =
     if (fs.stat! 'config.json'.is file ())
@@ -182,8 +182,8 @@ config =
 
 // para executar duas chamadas assíncronas de forma concorrente, use o
 // operador `?`.
-// O operador `?` retorna um *future* que pode ser executado aguardando
-// o resultado, novamente utilizando o operador `o`
+// O operador `?` retorna um *future*, que pode ser executado para
+// aguardar o resultado, novamente utilizando o operador `!`
 
 // nós não esperamos nenhuma dessas chamadas serem concluídas
 a = fs.stat? 'a.txt'
-- 
cgit v1.2.3


From 9fcfa2c91feb2af119e67c9d1897340e87f03daa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Thu, 22 Oct 2015 00:37:46 -0200
Subject: File name changed

---
 pt-br/pogo-pt.html.markdown | 202 ++++++++++++++++++++++++++++++++++++++++++++
 pt-br/pogo.html.markdown    | 202 --------------------------------------------
 2 files changed, 202 insertions(+), 202 deletions(-)
 create mode 100644 pt-br/pogo-pt.html.markdown
 delete mode 100644 pt-br/pogo.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/pogo-pt.html.markdown b/pt-br/pogo-pt.html.markdown
new file mode 100644
index 00000000..124b32f7
--- /dev/null
+++ b/pt-br/pogo-pt.html.markdown
@@ -0,0 +1,202 @@
+---
+language: pogoscript
+contributors:
+    - ["Tim Macfarlane", "http://github.com/refractalize"]
+    - ["Cássio Böck", "https://github.com/cassiobsilva"]
+filename: learnPogo-pt-br.pogo
+lang: pt-br
+---
+
+Pogoscript é uma linguagem de programação que possui tipos primitivos concorrents
+e que compila para linguagem Javascript padrão.
+
+``` javascript
+// definindo uma variável
+water temperature = 24
+
+// reatribuindo o valor de uma variável após a sua definição
+water temperature := 26
+
+// funções permitem que seus parâmetros sejam colocados em qualquer lugar
+temperature at (a) altitude = 32 - a / 100
+
+// funções longas são apenas indentadas
+temperature at (a) altitude :=
+    if (a < 0)
+        water temperature
+    else
+        32 - a / 100
+
+// declarando uma função
+current temperature = temperature at 3200 altitude
+
+// essa função cria um novo objeto com métodos
+position (x, y) = {
+    x = x
+    y = y
+
+    distance from position (p) =
+        dx = self.x - p.x
+        dy = self.y - p.y
+        Math.sqrt (dx * dx + dy * dy)
+}
+
+// `self` é similiar ao `this` do Javascript, com exceção de que `self` não
+// é redefinido em cada nova função
+
+// declaração de métodos
+position (7, 2).distance from position (position (5, 1))
+
+// assim como no Javascript, objetos também são hashes
+position.'x' == position.x == position.('x')
+
+// arrays
+positions = [
+    position (1, 1)
+    position (1, 2)
+    position (1, 3)
+]
+
+// indexando um array
+positions.0.y
+
+n = 2
+positions.(n).y
+
+// strings
+poem = 'Tail turned to red sunset on a juniper crown a lone magpie cawks.
+        Mad at Oryoki in the shrine-room -- Thistles blossomed late afternoon.
+        Put on my shirt and took it off in the sun walking the path to lunch.
+        A dandelion seed floats above the marsh grass with the mosquitos.
+        At 4 A.M. the two middleaged men sleeping together holding hands.
+        In the half-light of dawn a few birds warble under the Pleiades.
+        Sky reddens behind fir trees, larks twitter, sparrows cheep cheep cheep
+        cheep cheep.'
+
+// texto de Allen Ginsburg
+
+// interpolação
+outlook = 'amazing!'
+console.log "the weather tomorrow is going to be #(outlook)"
+
+// expressões regulares
+r/(\d+)m/i
+r/(\d+) degrees/mg
+
+// operadores
+true @and true
+false @or true
+@not false
+2 < 4
+2 >= 2
+2 > 1
+
+// os operadores padrão do Javascript também são suportados
+
+// definindo seu próprio operador
+(p1) plus (p2) =
+    position (p1.x + p2.x, p1.y + p2.y)
+
+// `plus` pode ser usado com um operador
+position (1, 1) @plus position (0, 2)
+// ou como uma função
+(position (1, 1)) plus (position (0, 2))
+
+// retorno explícito
+(x) times (y) = return (x * y)
+
+// new
+now = @new Date ()
+
+// funções podem receber argumentos opcionais
+spark (position, color: 'black', velocity: {x = 0, y = 0}) = {
+    color = color
+    position = position
+    velocity = velocity
+}
+
+red = spark (position 1 1, color: 'red')
+fast black = spark (position 1 1, velocity: {x = 10, y = 0})
+
+// funções também podem ser utilizadas para realizar o "unsplat" de argumentos
+log (messages, ...) =
+    console.log (messages, ...)
+
+// blocos são funções passadas para outras funções.
+// Este bloco recebe dois parâmetros, `spark` e `c`,
+// o corpo do bloco é o código indentado após a declaração da função
+
+render each @(spark) into canvas context @(c)
+    ctx.begin path ()
+    ctx.stroke style = spark.color
+    ctx.arc (
+        spark.position.x + canvas.width / 2
+        spark.position.y
+        3
+        0
+        Math.PI * 2
+    )
+    ctx.stroke ()
+
+// chamadas assíncronas
+
+// O Javascript, tanto no navegador quanto no servidor (através do Node.js)
+// realiza um uso massivo de funções assíncronas de E/S (entrada/saída) com
+// chamadas de retorno (callbacks). A E/S assíncrona é ótima para a performance e
+// torna a utilização da concorrência simples, porém pode rapidamente se tornar
+// algo complicado.
+// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono muito
+// mais fácil
+
+// O Node.js inclui o móduolo `fs` para acessar o sistema de arquivos.
+// Vamos listar o conteúdo de um diretório
+
+fs = require 'fs'
+directory listing = fs.readdir! '.'
+
+// `fs.readdir()` é uma função assíncrona, então nos a chamamos usando o
+// operador `!`. O operador `!` permite que você chame funções assíncronas
+// com a mesma sintaxe e a mesma semântica do que as demais funções síncronas.
+// O Pogoscript reescreve a função para que todo código inserido após o
+//  operador seja inserido em uma função de callback para o `fs.readdir()`.
+
+// obtendo erros ao utilizar funções assíncronas
+
+try
+    another directory listing = fs.readdir! 'a-missing-dir'
+catch (ex)
+    console.log (ex)
+
+// na verdade, se você não usar o `try catch`, o erro será passado para o
+// `try catch` mais externo do evento, assim como é feito em exceções síncronas
+
+// todo o controle de estrutura também funciona com chamadas assíncronas
+// aqui um exemplo de `if else`
+config =
+    if (fs.stat! 'config.json'.is file ())
+        JSON.parse (fs.read file! 'config.json' 'utf-8')
+    else
+        {
+            color: 'red'
+        }
+
+// para executar duas chamadas assíncronas de forma concorrente, use o
+// operador `?`.
+// O operador `?` retorna um *future*, que pode ser executado para
+// aguardar o resultado, novamente utilizando o operador `!`
+
+// nós não esperamos nenhuma dessas chamadas serem concluídas
+a = fs.stat? 'a.txt'
+b = fs.stat? 'b.txt'
+
+// agora nos aguardamos o término das chamadas e escrevemos os resultados
+console.log "size of a.txt is #(a!.size)"
+console.log "size of b.txt is #(b!.size)"
+
+// no Pogoscript, futures são semelhantes a Promises
+```
+E encerramos por aqui.
+
+Baixe o [Node.js](http://nodejs.org/) e execute `npm install pogo`.
+
+Há bastante documentação em [http://pogoscript.org/](http://pogoscript.org/), incluindo um material para [consulta rápida](http://pogoscript.org/cheatsheet.html), um [guia](http://pogoscript.org/guide/), e como o [Pogoscript é traduzido para o Javascript](http://featurist.github.io/pogo-examples/). Entre em contato através do [grupo do Google](http://groups.google.com/group/pogoscript) se você possui dúvidas!
diff --git a/pt-br/pogo.html.markdown b/pt-br/pogo.html.markdown
deleted file mode 100644
index 124b32f7..00000000
--- a/pt-br/pogo.html.markdown
+++ /dev/null
@@ -1,202 +0,0 @@
----
-language: pogoscript
-contributors:
-    - ["Tim Macfarlane", "http://github.com/refractalize"]
-    - ["Cássio Böck", "https://github.com/cassiobsilva"]
-filename: learnPogo-pt-br.pogo
-lang: pt-br
----
-
-Pogoscript é uma linguagem de programação que possui tipos primitivos concorrents
-e que compila para linguagem Javascript padrão.
-
-``` javascript
-// definindo uma variável
-water temperature = 24
-
-// reatribuindo o valor de uma variável após a sua definição
-water temperature := 26
-
-// funções permitem que seus parâmetros sejam colocados em qualquer lugar
-temperature at (a) altitude = 32 - a / 100
-
-// funções longas são apenas indentadas
-temperature at (a) altitude :=
-    if (a < 0)
-        water temperature
-    else
-        32 - a / 100
-
-// declarando uma função
-current temperature = temperature at 3200 altitude
-
-// essa função cria um novo objeto com métodos
-position (x, y) = {
-    x = x
-    y = y
-
-    distance from position (p) =
-        dx = self.x - p.x
-        dy = self.y - p.y
-        Math.sqrt (dx * dx + dy * dy)
-}
-
-// `self` é similiar ao `this` do Javascript, com exceção de que `self` não
-// é redefinido em cada nova função
-
-// declaração de métodos
-position (7, 2).distance from position (position (5, 1))
-
-// assim como no Javascript, objetos também são hashes
-position.'x' == position.x == position.('x')
-
-// arrays
-positions = [
-    position (1, 1)
-    position (1, 2)
-    position (1, 3)
-]
-
-// indexando um array
-positions.0.y
-
-n = 2
-positions.(n).y
-
-// strings
-poem = 'Tail turned to red sunset on a juniper crown a lone magpie cawks.
-        Mad at Oryoki in the shrine-room -- Thistles blossomed late afternoon.
-        Put on my shirt and took it off in the sun walking the path to lunch.
-        A dandelion seed floats above the marsh grass with the mosquitos.
-        At 4 A.M. the two middleaged men sleeping together holding hands.
-        In the half-light of dawn a few birds warble under the Pleiades.
-        Sky reddens behind fir trees, larks twitter, sparrows cheep cheep cheep
-        cheep cheep.'
-
-// texto de Allen Ginsburg
-
-// interpolação
-outlook = 'amazing!'
-console.log "the weather tomorrow is going to be #(outlook)"
-
-// expressões regulares
-r/(\d+)m/i
-r/(\d+) degrees/mg
-
-// operadores
-true @and true
-false @or true
-@not false
-2 < 4
-2 >= 2
-2 > 1
-
-// os operadores padrão do Javascript também são suportados
-
-// definindo seu próprio operador
-(p1) plus (p2) =
-    position (p1.x + p2.x, p1.y + p2.y)
-
-// `plus` pode ser usado com um operador
-position (1, 1) @plus position (0, 2)
-// ou como uma função
-(position (1, 1)) plus (position (0, 2))
-
-// retorno explícito
-(x) times (y) = return (x * y)
-
-// new
-now = @new Date ()
-
-// funções podem receber argumentos opcionais
-spark (position, color: 'black', velocity: {x = 0, y = 0}) = {
-    color = color
-    position = position
-    velocity = velocity
-}
-
-red = spark (position 1 1, color: 'red')
-fast black = spark (position 1 1, velocity: {x = 10, y = 0})
-
-// funções também podem ser utilizadas para realizar o "unsplat" de argumentos
-log (messages, ...) =
-    console.log (messages, ...)
-
-// blocos são funções passadas para outras funções.
-// Este bloco recebe dois parâmetros, `spark` e `c`,
-// o corpo do bloco é o código indentado após a declaração da função
-
-render each @(spark) into canvas context @(c)
-    ctx.begin path ()
-    ctx.stroke style = spark.color
-    ctx.arc (
-        spark.position.x + canvas.width / 2
-        spark.position.y
-        3
-        0
-        Math.PI * 2
-    )
-    ctx.stroke ()
-
-// chamadas assíncronas
-
-// O Javascript, tanto no navegador quanto no servidor (através do Node.js)
-// realiza um uso massivo de funções assíncronas de E/S (entrada/saída) com
-// chamadas de retorno (callbacks). A E/S assíncrona é ótima para a performance e
-// torna a utilização da concorrência simples, porém pode rapidamente se tornar
-// algo complicado.
-// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono muito
-// mais fácil
-
-// O Node.js inclui o móduolo `fs` para acessar o sistema de arquivos.
-// Vamos listar o conteúdo de um diretório
-
-fs = require 'fs'
-directory listing = fs.readdir! '.'
-
-// `fs.readdir()` é uma função assíncrona, então nos a chamamos usando o
-// operador `!`. O operador `!` permite que você chame funções assíncronas
-// com a mesma sintaxe e a mesma semântica do que as demais funções síncronas.
-// O Pogoscript reescreve a função para que todo código inserido após o
-//  operador seja inserido em uma função de callback para o `fs.readdir()`.
-
-// obtendo erros ao utilizar funções assíncronas
-
-try
-    another directory listing = fs.readdir! 'a-missing-dir'
-catch (ex)
-    console.log (ex)
-
-// na verdade, se você não usar o `try catch`, o erro será passado para o
-// `try catch` mais externo do evento, assim como é feito em exceções síncronas
-
-// todo o controle de estrutura também funciona com chamadas assíncronas
-// aqui um exemplo de `if else`
-config =
-    if (fs.stat! 'config.json'.is file ())
-        JSON.parse (fs.read file! 'config.json' 'utf-8')
-    else
-        {
-            color: 'red'
-        }
-
-// para executar duas chamadas assíncronas de forma concorrente, use o
-// operador `?`.
-// O operador `?` retorna um *future*, que pode ser executado para
-// aguardar o resultado, novamente utilizando o operador `!`
-
-// nós não esperamos nenhuma dessas chamadas serem concluídas
-a = fs.stat? 'a.txt'
-b = fs.stat? 'b.txt'
-
-// agora nos aguardamos o término das chamadas e escrevemos os resultados
-console.log "size of a.txt is #(a!.size)"
-console.log "size of b.txt is #(b!.size)"
-
-// no Pogoscript, futures são semelhantes a Promises
-```
-E encerramos por aqui.
-
-Baixe o [Node.js](http://nodejs.org/) e execute `npm install pogo`.
-
-Há bastante documentação em [http://pogoscript.org/](http://pogoscript.org/), incluindo um material para [consulta rápida](http://pogoscript.org/cheatsheet.html), um [guia](http://pogoscript.org/guide/), e como o [Pogoscript é traduzido para o Javascript](http://featurist.github.io/pogo-examples/). Entre em contato através do [grupo do Google](http://groups.google.com/group/pogoscript) se você possui dúvidas!
-- 
cgit v1.2.3


From d9d8de0d229443534272e2a1976fb7f0e69631b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Sun, 25 Oct 2015 15:44:35 -0200
Subject: Translator section added

Changed my name from contributor section to the translator section
---
 pt-br/pogo-pt.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'pt-br')

diff --git a/pt-br/pogo-pt.html.markdown b/pt-br/pogo-pt.html.markdown
index 124b32f7..80dcfcd5 100644
--- a/pt-br/pogo-pt.html.markdown
+++ b/pt-br/pogo-pt.html.markdown
@@ -2,6 +2,7 @@
 language: pogoscript
 contributors:
     - ["Tim Macfarlane", "http://github.com/refractalize"]
+translators:
     - ["Cássio Böck", "https://github.com/cassiobsilva"]
 filename: learnPogo-pt-br.pogo
 lang: pt-br
-- 
cgit v1.2.3


From 762af2de245ab665af0e4b1397acc960d25932f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?C=C3=A1ssio=20B=C3=B6ck?= <cassio.bock@gmail.com>
Date: Thu, 29 Oct 2015 23:29:46 -0200
Subject: Fixing typos

Fixing pt-br typos
---
 pt-br/c-pt.html.markdown    |  71 ++++++++--------
 pt-br/pogo-pt.html.markdown | 203 --------------------------------------------
 2 files changed, 36 insertions(+), 238 deletions(-)
 delete mode 100644 pt-br/pogo-pt.html.markdown

(limited to 'pt-br')

diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 43688724..2c274f12 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -7,29 +7,30 @@ contributors:
 translators:
     - ["João Farias", "https://github.com/JoaoGFarias"]
     - ["Elton Viana", "https://github.com/eltonvs"]
+    - ["Cássio Böck", "https://github.com/cassiobsilva"]
 lang: pt-br
 filename: c-pt.el
 ---
 
 Ah, C. Ainda é **a** linguagem de computação de alta performance.
 
-C é a liguangem de mais baixo nível que a maioria dos programadores
-irão usar, e isso dá a ela uma grande velocidade bruta. Apenas fique
-antento que este manual de gerenciamento de memória e C vai levanter-te
-tão longe quanto você precisa. 
+C é a linguagem de mais baixo nível que a maioria dos programadores
+utilizarão, e isso dá a ela uma grande velocidade bruta. Apenas fique
+atento se este manual de gerenciamento de memória e C vai te levar
+tão longe quanto precisa.
 
 ```c
 // Comentários de uma linha iniciam-se com // - apenas disponível a partir do C99
 
 /*
-Comentários de multiplas linhas se parecem com este. 
+Comentários de múltiplas linhas se parecem com este.
 Funcionam no C89 também.
 */
 
 // Constantes: #define <palavra-chave>
 #definie DAY_IN_YEAR 365
 
-//enumarações também são modos de definir constantes.
+//enumerações também são modos de definir constantes.
 enum day {DOM = 1, SEG, TER, QUA, QUI, SEX, SAB};
 // SEG recebe 2 automaticamente, TER recebe 3, etc.
 
@@ -54,13 +55,13 @@ int soma_dois_ints(int x1, int x2); // protótipo de função
 // O ponto de entrada do teu programa é uma função
 // chamada main, com tipo de retorno inteiro
 int main() {
-	// Usa-se printf para escrever na tela, 
+	// Usa-se printf para escrever na tela,
 	// para "saída formatada"
 	// %d é um inteiro, \n é uma nova linha
     printf("%d\n", 0); // => Imprime 0
 	// Todos as declarações devem acabar com
 	// ponto e vírgula
-	
+
     ///////////////////////////////////////
     // Tipos
     ///////////////////////////////////////
@@ -78,7 +79,7 @@ int main() {
     // longs tem entre 4 e 8 bytes; longs long tem garantia
     // de ter pelo menos 64 bits
     long x_long = 0;
-    long long x_long_long = 0; 
+    long long x_long_long = 0;
 
     // floats são normalmente números de ponto flutuante
 	// com 32 bits
@@ -93,7 +94,7 @@ int main() {
     unsigned int ux_int;
     unsigned long long ux_long_long;
 
-	// caracteres dentro de aspas simples são inteiros 
+	// caracteres dentro de aspas simples são inteiros
 	// no conjunto de caracteres da máquina.
     '0' // => 48 na tabela ASCII.
     'A' // => 65 na tabela ASCII.
@@ -104,7 +105,7 @@ int main() {
 
 	// Se o argumento do operador `sizeof` é uma expressão, então seus argumentos
 	// não são avaliados (exceto em VLAs (veja abaixo)).
-	// O valor devolve, neste caso, é uma constante de tempo de compilação. 
+	// O valor devolve, neste caso, é uma constante de tempo de compilação.
     int a = 1;
 	// size_t é um inteiro sem sinal com pelo menos 2 bytes que representa
 	// o tamanho de um objeto.
@@ -120,7 +121,7 @@ int main() {
 	// Você pode inicializar um array com 0 desta forma:
     char meu_array[20] = {0};
 
-	// Indexar um array é semelhante a outras linguages
+	// Indexar um array é semelhante a outras linguagens
 	// Melhor dizendo, outras linguagens são semelhantes a C
     meu_array[0]; // => 0
 
@@ -129,7 +130,7 @@ int main() {
     printf("%d\n", meu_array[1]); // => 2
 
 	// No C99 (e como uma features opcional em C11), arrays de tamanho variável
-	// VLA (do inglês), podem ser declarados também. O tamanho destes arrays 
+	// VLA (do inglês), podem ser declarados também. O tamanho destes arrays
 	// não precisam ser uma constante de tempo de compilação:
     printf("Entre o tamanho do array: "); // Pergunta ao usuário pelo tamanho
     char buf[0x100];
@@ -144,14 +145,14 @@ int main() {
     // > Entre o tamanho do array: 10
     // > sizeof array = 40
 
-	// String são apenas arrays de caracteres terminados por um 
+	// String são apenas arrays de caracteres terminados por um
 	// byte nulo (0x00), representado em string pelo caracter especial '\0'.
 	// (Não precisamos incluir o byte nulo em literais de string; o compilador
 	// o insere ao final do array para nós.)
-    char uma_string[20] = "Isto é uma string"; 
+    char uma_string[20] = "Isto é uma string";
 	// Observe que 'é' não está na tabela ASCII
 	// A string vai ser salva, mas a saída vai ser estranha
-	// Porém, comentários podem conter acentos 
+	// Porém, comentários podem conter acentos
     printf("%s\n", uma_string); // %s formata a string
 
     printf("%d\n", uma_string[17]); // => 0
@@ -175,7 +176,7 @@ int main() {
     ///////////////////////////////////////
 
     // Atalho para multiplas declarações:
-    int i1 = 1, i2 = 2; 
+    int i1 = 1, i2 = 2;
     float f1 = 1.0, f2 = 2.0;
 
     int a, b, c;
@@ -206,7 +207,7 @@ int main() {
     2 <= 2; // => 1
     2 >= 2; // => 1
 
-	// C não é Python - comparações não se encadeam.
+	// C não é Python - comparações não se encadeiam.
     int a = 1;
     // Errado:
     int entre_0_e_2 = 0 < a < 2;
@@ -231,7 +232,7 @@ int main() {
     char *s = "iLoveC";
     int j = 0;
     s[j++]; // => "i". Retorna o j-ésimo item de s E DEPOIS incrementa o valor de j.
-    j = 0; 
+    j = 0;
     s[++j]; // => "L". Incrementa o valor de j. E DEPOIS retorna o j-ésimo item de s.
     // o mesmo com j-- e --j
 
@@ -308,7 +309,7 @@ int main() {
         exit(-1);
         break;
     }
-    
+
 
     ///////////////////////////////////////
     // Cast de tipos
@@ -327,8 +328,8 @@ int main() {
 	// Tipos irão ter overflow sem aviso
     printf("%d\n", (unsigned char) 257); // => 1 (Max char = 255 se char tem 8 bits)
 
-	// Para determinar o valor máximo de um `char`, de um `signed char` e de 
-	// um `unisigned char`, respectivamente, use as macros CHAR_MAX, SCHAR_MAX 
+	// Para determinar o valor máximo de um `char`, de um `signed char` e de
+	// um `unisigned char`, respectivamente, use as macros CHAR_MAX, SCHAR_MAX
 	// e UCHAR_MAX de <limits.h>
 
 	// Tipos inteiros podem sofrer cast para pontos-flutuantes e vice-versa.
@@ -341,7 +342,7 @@ int main() {
     ///////////////////////////////////////
 
 	// Um ponteiro é uma variável declarada para armazenar um endereço de memória.
-	// Seu declaração irá também dizer o tipo de dados para o qual ela aponta. Você
+	// Sua declaração irá também dizer o tipo de dados para o qual ela aponta. Você
 	// Pode usar o endereço de memória de suas variáveis, então, brincar com eles.
 
     int x = 0;
@@ -363,13 +364,13 @@ int main() {
     printf("%d\n", *px); // => Imprime 0, o valor de x
 
 	// Você também pode mudar o valor que o ponteiro está apontando.
-	// Teremo que cercar a de-referência entre parenteses, pois
+	// Temos que cercar a de-referência entre parênteses, pois
 	// ++ tem uma precedência maior que *.
     (*px)++; // Incrementa o valor que px está apontando por 1
     printf("%d\n", *px); // => Imprime 1
     printf("%d\n", x); // => Imprime 1
 
-	// Arrays são um boa maneira de alocar um bloco contínuo de memória
+	// Arrays são uma boa maneira de alocar um bloco contínuo de memória
     int x_array[20]; // Declara um array de tamanho 20 (não pode-se mudar o tamanho
     int xx;
     for (xx = 0; xx < 20; xx++) {
@@ -379,7 +380,7 @@ int main() {
 	// Declara um ponteiro do tipo int e inicialize ele para apontar para x_array
     int* x_ptr = x_array;
 	// x_ptr agora aponta para o primeiro elemento do array (o inteiro 20).
-	// Isto funciona porque arrays são apenas ponteiros para seu primeiros elementos.
+	// Isto funciona porque arrays são apenas ponteiros para seus primeiros elementos.
 	// Por exemplo, quando um array é passado para uma função ou é atribuído a um
 	// ponteiro, ele transforma-se (convertido implicitamente) em um ponteiro.
 	// Exceções: quando o array é o argumento de um operador `&` (endereço-de):
@@ -395,7 +396,7 @@ int main() {
     printf("%zu, %zu\n", sizeof arr, sizeof ptr); // provavelmente imprime "40, 4" ou "40, 8"
 
 	// Ponteiros podem ser incrementados ou decrementados baseado no seu tipo
-	// (isto é chamado aritimética de ponteiros
+	// (isto é chamado aritmética de ponteiros
     printf("%d\n", *(x_ptr + 1)); // => Imprime 19
     printf("%d\n", x_array[1]); // => Imprime 19
 
@@ -413,9 +414,9 @@ int main() {
 	// "resultados imprevisíveis" - o programa é dito ter um "comportamento indefinido"
     printf("%d\n", *(my_ptr + 21)); // => Imprime quem-sabe-o-que? Talvez até quebre o programa.
 
-	// Quando termina-se de usar um bloco de memória alocado, você pode liberá-lo,
+	// Quando se termina de usar um bloco de memória alocado, você pode liberá-lo,
 	// ou ninguém mais será capaz de usá-lo até o fim da execução
-	// (Isto cham-se "memory leak"):
+	// (Isto chama-se "memory leak"):
     free(my_ptr);
 
 	// Strings são arrays de char, mas elas geralmente são representadas
@@ -537,7 +538,7 @@ int area(retan r)
     return r.largura * r.altura;
 }
 
-// Se você tiver structus grande, você pode passá-las "por ponteiro" 
+// Se você tiver structus grande, você pode passá-las "por ponteiro"
 // para evitar cópia de toda a struct:
 int area(const retan *r)
 {
@@ -554,8 +555,8 @@ conhecidos. Ponteiros para funções são como qualquer outro ponteiro
 diretamente e passá-las para por toda parte.
 Entretanto, a sintaxe de definição por ser um pouco confusa.
 
-Exemplo: use str_reverso através de um ponteiro 
-*/	
+Exemplo: use str_reverso através de um ponteiro
+*/
 void str_reverso_através_ponteiro(char *str_entrada) {
     // Define uma variável de ponteiro para função, nomeada f.
     void (*f)(char *); //Assinatura deve ser exatamente igual à função alvo.
@@ -575,7 +576,7 @@ typedef void (*minha_função_type)(char *);
 
 // Declarando o ponteiro:
 // ...
-// minha_função_type f; 
+// minha_função_type f;
 
 //Caracteres especiais:
 '\a' // Alerta (sino)
@@ -586,7 +587,7 @@ typedef void (*minha_função_type)(char *);
 '\r' // Retorno de carroça
 '\b' // Backspace
 '\0' // Caracter nulo. Geralmente colocado ao final de string em C.
-     //   oi\n\0. \0 é usado por convenção para marcar o fim da string. 
+     //   oi\n\0. \0 é usado por convenção para marcar o fim da string.
 '\\' // Barra invertida
 '\?' // Interrogação
 '\'' // Aspas simples
@@ -606,7 +607,7 @@ typedef void (*minha_função_type)(char *);
 "%p"    // ponteiro
 "%x"    // hexadecimal
 "%o"    // octal
-"%%"    // imprime % 
+"%%"    // imprime %
 
 ///////////////////////////////////////
 // Ordem de avaliação
diff --git a/pt-br/pogo-pt.html.markdown b/pt-br/pogo-pt.html.markdown
deleted file mode 100644
index 80dcfcd5..00000000
--- a/pt-br/pogo-pt.html.markdown
+++ /dev/null
@@ -1,203 +0,0 @@
----
-language: pogoscript
-contributors:
-    - ["Tim Macfarlane", "http://github.com/refractalize"]
-translators:
-    - ["Cássio Böck", "https://github.com/cassiobsilva"]
-filename: learnPogo-pt-br.pogo
-lang: pt-br
----
-
-Pogoscript é uma linguagem de programação que possui tipos primitivos concorrents
-e que compila para linguagem Javascript padrão.
-
-``` javascript
-// definindo uma variável
-water temperature = 24
-
-// reatribuindo o valor de uma variável após a sua definição
-water temperature := 26
-
-// funções permitem que seus parâmetros sejam colocados em qualquer lugar
-temperature at (a) altitude = 32 - a / 100
-
-// funções longas são apenas indentadas
-temperature at (a) altitude :=
-    if (a < 0)
-        water temperature
-    else
-        32 - a / 100
-
-// declarando uma função
-current temperature = temperature at 3200 altitude
-
-// essa função cria um novo objeto com métodos
-position (x, y) = {
-    x = x
-    y = y
-
-    distance from position (p) =
-        dx = self.x - p.x
-        dy = self.y - p.y
-        Math.sqrt (dx * dx + dy * dy)
-}
-
-// `self` é similiar ao `this` do Javascript, com exceção de que `self` não
-// é redefinido em cada nova função
-
-// declaração de métodos
-position (7, 2).distance from position (position (5, 1))
-
-// assim como no Javascript, objetos também são hashes
-position.'x' == position.x == position.('x')
-
-// arrays
-positions = [
-    position (1, 1)
-    position (1, 2)
-    position (1, 3)
-]
-
-// indexando um array
-positions.0.y
-
-n = 2
-positions.(n).y
-
-// strings
-poem = 'Tail turned to red sunset on a juniper crown a lone magpie cawks.
-        Mad at Oryoki in the shrine-room -- Thistles blossomed late afternoon.
-        Put on my shirt and took it off in the sun walking the path to lunch.
-        A dandelion seed floats above the marsh grass with the mosquitos.
-        At 4 A.M. the two middleaged men sleeping together holding hands.
-        In the half-light of dawn a few birds warble under the Pleiades.
-        Sky reddens behind fir trees, larks twitter, sparrows cheep cheep cheep
-        cheep cheep.'
-
-// texto de Allen Ginsburg
-
-// interpolação
-outlook = 'amazing!'
-console.log "the weather tomorrow is going to be #(outlook)"
-
-// expressões regulares
-r/(\d+)m/i
-r/(\d+) degrees/mg
-
-// operadores
-true @and true
-false @or true
-@not false
-2 < 4
-2 >= 2
-2 > 1
-
-// os operadores padrão do Javascript também são suportados
-
-// definindo seu próprio operador
-(p1) plus (p2) =
-    position (p1.x + p2.x, p1.y + p2.y)
-
-// `plus` pode ser usado com um operador
-position (1, 1) @plus position (0, 2)
-// ou como uma função
-(position (1, 1)) plus (position (0, 2))
-
-// retorno explícito
-(x) times (y) = return (x * y)
-
-// new
-now = @new Date ()
-
-// funções podem receber argumentos opcionais
-spark (position, color: 'black', velocity: {x = 0, y = 0}) = {
-    color = color
-    position = position
-    velocity = velocity
-}
-
-red = spark (position 1 1, color: 'red')
-fast black = spark (position 1 1, velocity: {x = 10, y = 0})
-
-// funções também podem ser utilizadas para realizar o "unsplat" de argumentos
-log (messages, ...) =
-    console.log (messages, ...)
-
-// blocos são funções passadas para outras funções.
-// Este bloco recebe dois parâmetros, `spark` e `c`,
-// o corpo do bloco é o código indentado após a declaração da função
-
-render each @(spark) into canvas context @(c)
-    ctx.begin path ()
-    ctx.stroke style = spark.color
-    ctx.arc (
-        spark.position.x + canvas.width / 2
-        spark.position.y
-        3
-        0
-        Math.PI * 2
-    )
-    ctx.stroke ()
-
-// chamadas assíncronas
-
-// O Javascript, tanto no navegador quanto no servidor (através do Node.js)
-// realiza um uso massivo de funções assíncronas de E/S (entrada/saída) com
-// chamadas de retorno (callbacks). A E/S assíncrona é ótima para a performance e
-// torna a utilização da concorrência simples, porém pode rapidamente se tornar
-// algo complicado.
-// O Pogoscript possui algumas coisas que tornam o uso de E/S assíncrono muito
-// mais fácil
-
-// O Node.js inclui o móduolo `fs` para acessar o sistema de arquivos.
-// Vamos listar o conteúdo de um diretório
-
-fs = require 'fs'
-directory listing = fs.readdir! '.'
-
-// `fs.readdir()` é uma função assíncrona, então nos a chamamos usando o
-// operador `!`. O operador `!` permite que você chame funções assíncronas
-// com a mesma sintaxe e a mesma semântica do que as demais funções síncronas.
-// O Pogoscript reescreve a função para que todo código inserido após o
-//  operador seja inserido em uma função de callback para o `fs.readdir()`.
-
-// obtendo erros ao utilizar funções assíncronas
-
-try
-    another directory listing = fs.readdir! 'a-missing-dir'
-catch (ex)
-    console.log (ex)
-
-// na verdade, se você não usar o `try catch`, o erro será passado para o
-// `try catch` mais externo do evento, assim como é feito em exceções síncronas
-
-// todo o controle de estrutura também funciona com chamadas assíncronas
-// aqui um exemplo de `if else`
-config =
-    if (fs.stat! 'config.json'.is file ())
-        JSON.parse (fs.read file! 'config.json' 'utf-8')
-    else
-        {
-            color: 'red'
-        }
-
-// para executar duas chamadas assíncronas de forma concorrente, use o
-// operador `?`.
-// O operador `?` retorna um *future*, que pode ser executado para
-// aguardar o resultado, novamente utilizando o operador `!`
-
-// nós não esperamos nenhuma dessas chamadas serem concluídas
-a = fs.stat? 'a.txt'
-b = fs.stat? 'b.txt'
-
-// agora nos aguardamos o término das chamadas e escrevemos os resultados
-console.log "size of a.txt is #(a!.size)"
-console.log "size of b.txt is #(b!.size)"
-
-// no Pogoscript, futures são semelhantes a Promises
-```
-E encerramos por aqui.
-
-Baixe o [Node.js](http://nodejs.org/) e execute `npm install pogo`.
-
-Há bastante documentação em [http://pogoscript.org/](http://pogoscript.org/), incluindo um material para [consulta rápida](http://pogoscript.org/cheatsheet.html), um [guia](http://pogoscript.org/guide/), e como o [Pogoscript é traduzido para o Javascript](http://featurist.github.io/pogo-examples/). Entre em contato através do [grupo do Google](http://groups.google.com/group/pogoscript) se você possui dúvidas!
-- 
cgit v1.2.3