Add translate until Haskell::IO

Plus some extra references

1 files changed, 119 insertions, 102 deletions

diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown
index 3d80a44f..f9f9f510 100644
--- a/pt-br/haskell-pt.html.markdown
+++ b/pt-br/haskell-pt.html.markdown
@@ -227,22 +227,38 @@ let fatorial n = fatorial (n - 1) * n
    uma lista é `resto`  é o resto da lista.
 -}
 
-mapa mapeador [] = []
+mapa mapeador _ [] = []
 mapa mapeador (primeiro : resto) = mapeador primeiro : (mapa mapeador resto)
 
-{- Funções Anônimas são criadas com um `\` (barra invertida)
-   seguido por seus argumentos!
+{- Uma função anônima é uma função sem um nome.
+   É uma abstração do cálculo lambda:
+
+   \x -> x + 1
+   λ.x (x + 1)
+
+   Em Haskell Barra Invertida é um jeito para
+   se escrever Lambda (λ). Uma ótima pedida
+   Para entender Haskell e outras linguagens como Lisp
+   É estudar Cálculo Lambda, é um entendimento matemático
+   mais apurado. E do ponto de vista computacional é
+   bastante interessante. Em EXTRAS você encontrará
+   Links para aprender Cálculo Lambda.
 -}
-mapa (\primeiro -> primeiro + 2) [1..5] -- [3, 4, 5, 6, 7]
 
-{- Usar "fold" (chamado `inject` em algumas outras línguagens) com
-   uma função anônima.
+(\x -> x + 1) 4 -- 5
+
 
-   <foldl1> significa <fold left> E mapeia o primeiro valor
-   da lista para ser o acumulador.
+{- Algumas vezes é mais conveniente usar expressões lambda
+   do que definir um nome para uma função. Na matemática
+   Nomes são muito simbólicos. Isso acontece bastante
+   quando você estiver trabalhando `map` ou `foldl` / `foldr`
 -}
-foldl1 (\acc x -> acc + x) [1..5] -- 15
-foldl1 (\x y -> (x+y)/5) [7..55] -- 13.6875
+
+-- Sem usar expressões anônimas !
+listaSomaUm lst = map somaUm' lst where somaUm' x = x + 1
+
+-- Usando expressões anônimas !
+listaSomaUm' lst = map (\x -> x + 1) lst
 
 ----------------------------------------------------
 -- 4. Mais Funções
@@ -276,144 +292,142 @@ foo 5 -- 75
 {- Concertando precedência:
    Haskell tem outra função chamada `$`. Isso altera a precedência
    de computação. Ou seja Haskell computa o que está sendo sinalizado com $
-   da esquerda para a direita . You can use `.` and `$` to get rid of a lot
-   of parentheses:
+   da esquerda para a direita . Você pode usar `.` e `$` para se livrar
+   de parentízação desnecessária.
 -}
 
--- Antes
 (even (fatorial 3)) -- true
 
--- Depois
+-- Usando `.` e `$`
 even . fatorial $ 3 -- true
 
 ----------------------------------------------------
--- 4. More functions
+-- 5. Tipos
 ----------------------------------------------------
 
-{- Mais Sobre Funções Currificadas: se você não passar
-   todos os argumentos para uma função.
--}
-
-add a b = a + b
-foo = add 10 -- foo is now a function that takes a number and adds 10 to it
-foo 5 -- 15
-
--- Another way to write the same thing
-foo = (+10)
-foo 5 -- 15
+-- Haskell é fortemente tipado e tudo tem uma assinatura típica.
 
--- function composition
--- the (.) function chains functions together.
--- For example, here foo is a function that takes a value. It adds 10 to it,
--- multiplies the result of that by 5, and then returns the final value.
-foo = (*5) . (+10)
+-- Tipos Básicos:
+460 :: Integer
+"music" :: String
+True :: Bool
 
--- (5 + 10) * 5 = 75
-foo 5 -- 75
+{- Funções também tem tipos.
+   `not` recebe um booleano e retorna um booleano:
+   not :: Bool -> Bool
+-}
 
--- fixing precedence
--- Haskell has another function called `$`. This changes the precedence
--- so that everything to the left of it gets computed first and then applied
--- to everything on the right. You can use `.` and `$` to get rid of a lot
--- of parentheses:
+{- Aqui temos uma função que recebe dois argumentos
+   soma :: Integer -> Integer -> Integer
+-}
 
--- before
-(even (fib 7)) -- true
+{- Quando você define um valor em Haskell
+   uma boa prática de programação é escrever
+   o TIPO acima dessa mesma. Como segue:
+-}
 
--- after
-even . fib $ 7 -- true
+double :: Integer -> Integer
+double x = x * 2
 
 ----------------------------------------------------
--- 5. Type signatures
+-- 6. Controle de Fluxo e IF-THEN-ELSE
 ----------------------------------------------------
 
--- Haskell has a very strong type system, and everything has a type signature.
-
--- Some basic types:
-5 :: Integer
-"hello" :: String
-True :: Bool
+-- Blocos IF-THEN-ELSE
+let valor_alternado = if 144 `mod` 6 == 4 then "acertou" else "errou" -- errou
 
--- Functions have types too.
--- `not` takes a boolean and returns a boolean:
--- not :: Bool -> Bool
+-- É legal identar quando você tem múltiplos branchs para acontecer
 
--- Here's a function that takes two arguments:
--- add :: Integer -> Integer -> Integer
+let valor_alternado = if 144 `mod` 6 == 4
+                      then "acertou"
+                      else "errou"
 
--- When you define a value, it's good practice to write its type above it:
-double :: Integer -> Integer
-double x = x * 2
+-- Blocos CASE
 
-----------------------------------------------------
--- 6. Control Flow and If Statements
-----------------------------------------------------
+{- caso <argumento> seja :
+        <ajuda>  -> mostra_ajuda
+        <inicia> -> inicia_programa
+        <_>      -> putStrLn "ExArgumentoInvalido"
 
--- if statements
-haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
+    Onde `_` Significa Qualquer Outra Coisa.
+-}
 
--- if statements can be on multiple lines too, indentation is important
-haskell = if 1 == 1
-            then "awesome"
-            else "awful"
 
--- case statements: Here's how you could parse command line arguments
 case args of
-  "help" -> printHelp
-  "start" -> startProgram
-  _ -> putStrLn "bad args"
+     "ajuda"  -> mostra_ajuda
+     "inicia" -> inicia_programa
+     _        -> putStrLn "ExArgumentoInvalido"
 
--- Haskell doesn't have loops because it uses recursion instead.
--- map applies a function over every element in an array
+{- Haskell não funciona na base de loops pois ele é
+   fortemente baseado em funcões recursivas e cálculo lambda
 
+   Use `map` uma função build-in do interpretador
+   para, por exemplo, mapear uma lista:
+-}
 map (*2) [1..5] -- [2, 4, 6, 8, 10]
 
--- you can make a for function using map
-for array func = map func array
-
--- and then use it
+-- Você pode criar um FOR-LOOP usando map
+let for array funcao = map funcao array
 for [0..5] $ \i -> show i
 
--- we could've written that like this too:
+-- Ou ainda (Pesquise sobre show em Haskell):
 for [0..5] show
 
--- You can use foldl or foldr to reduce a list
--- foldl <fn> <initial value> <list>
+
+{- foldl computação é feita esquerda para direita
+   foldr computação é feita  direita para esquerda
+
+   Você pode usar foldl or foldr a fim de reduzir uma lista
+   fold(l||r) <funcao> <valor inicial> <lista>
+-}
+
+-- Fold Left
 foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
 
--- This is the same as
-(2 * (2 * (2 * 4 + 1) + 2) + 3)
+-- Pensando Recursivamente Esquerda-Direita
+(2 * (2 * (2 * 4 + 1) + 2) + 3) -- 43
 
--- foldl is left-handed, foldr is right-
+-- Fold Right
 foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
 
--- This is now the same as
+-- Pensando Recursivamente Direita-Esquerda
 (2 * 3 + (2 * 2 + (2 * 1 + 4)))
 
 ----------------------------------------------------
--- 7. Data Types
+-- 7. Declaração de Dados
 ----------------------------------------------------
 
--- Here's how you make your own data type in Haskell
-
-data Color = Red | Blue | Green
+{- Vamos começar definindo um tipo de
+   dado que é uma cor rgb então ela
+   tem valores para vermelho azul e verde
+   ela é composta desses 3 comprimentos
+   Vamos usar `data` e `say` que são built-in:
+   
+   Haskell pede que você user letra
+   maiuscula para tipos (types) ou classes (Class)
+   
+   Por favor, visite: http://www.haskell.org/haskellwiki/Type
+   E de uma olhada na fórmula genérica de declaração de dados.
+-}
 
--- Now you can use it in a function:
+data Cor = Vermelho | Azul | Verde
 
+-- say :: Color -> String
 
-say :: Color -> String
-say Red = "You are Red!"
-say Blue = "You are Blue!"
-say Green =  "You are Green!"
+let say Vermelho = "Vermelho"
+let say Azul = "Azul"
+let say Verde = "Verde"
 
--- Your data types can have parameters too:
+{- O seu tipo de dados por receber parâmetros também
+   vamos com um exemplo usando `data` e a Classe `Maybe`.
+-}
 
 data Maybe a = Nothing | Just a
 
--- These are all of type Maybe
-Just "hello"    -- of type `Maybe String`
-Just 1          -- of type `Maybe Int`
-Nothing         -- of type `Maybe a` for any `a`
+-- Just e Nothing são todos derivadas de Maybe
+Just "hello" -- tipo `Maybe String`
+Just 1       -- tipo `Maybe Int`
+Nothing      -- tipo `Maybe a` para algum `a`
 
 ----------------------------------------------------
 -- 8. Haskell IO
@@ -514,18 +528,15 @@ Prelude> let foo = 1.4
 
 Prelude> :t foo
 foo :: Double
-```
 
 ----------------------------------------------------
 -- 9. Mônadas
 ----------------------------------------------------
 
+```
 
 
-
-----------------------------------------------------
--- 10. Extra
-----------------------------------------------------
+# Extra
 
 Compilador e Interpretador Haskell
 
@@ -544,10 +555,16 @@ Aplicações Haskell Muito Interessantes:
 * [Bio Informática](http://www.haskell.org/haskellwiki/Applications_and_libraries/Bioinformatics)
 * [Muitos Outras Aplicações](http://www.haskell.org/haskellwiki/Libraries_and_tools)
 
+Comunidade Haskell
+* [Musica das Mônadas](http://www.haskell.org/haskellwiki/Music_of_monads)
+
 Tutoriais:
 
 * [Mapeadores](http://www.haskell.org/ghc/docs/6.12.2/html/libraries/containers-0.3.0.0/Data-Map.html)
 * [Aprenda Haskell!](http://haskell.tailorfontela.com.br/chapters)
+* [Fundação Teórica da Linguagem Haskell](http://www.haskell.org/haskellwiki/Lambda_calculus)
+* [Classe Maybe](http://www.haskell.org/haskellwiki/Maybe)
+* [Zvon Referência Haskell](http://www.zvon.org/other/haskell/)
 
 Obtenha Também Haskell Wiki Book [Aqui!](https://en.wikibooks.org/wiki/Haskell)