Add a complete translation on haskell guide

I have translated to brazilian portuguese your Haskell quick guide written by Adit Bhargava plus i have add some new ideas.

pt-br/haskell-pt.html.markdown

@@ -429,86 +429,132 @@ Just "hello" -- tipo `Maybe String`
 Just 1       -- tipo `Maybe Int`
 Nothing      -- tipo `Maybe a` para algum `a`
 
+
 ----------------------------------------------------
--- 8. Haskell IO
+-- 8. Mônadas
 ----------------------------------------------------
 
--- While IO can't be explained fully without explaining monads,
+{- As mônadas permitem que o programador construa computações
--- it is not hard to explain enough to get going.
+   sando os blocos de comando sequenciais, os quais, por sua vez,
+   podem ter outras sequencias de computações. Para entender melhor
+   a classe Monads você precisa ler um pouco mais sobre Classes em
+   Haskell e o polímofirmo ad hoc do Haskell.
 
--- When a Haskell program is executed, the function `main` is
+   A Classe Mônada padrão em Haskell é a seguinte:
--- called. It must return a value of type `IO ()`. For example:
+-}
 
-main :: IO ()
+class Monad m where
-main = putStrLn $ "Hello, sky! " ++ (say Blue)
+  (>>=)  :: m a -> (a -> m b) -> m b
--- putStrLn has type String -> IO ()
+  (>>)   :: m a -> m b -> m b
+  return :: m -> m a
+  fail   :: String -> m a
 
--- It is easiest to do IO if you can implement your program as
+  -- Definição completa mínima:
--- a function from String to String. The function
+  -- (>>=), return
---    interact :: (String -> String) -> IO ()
--- inputs some text, runs a function on it, and prints out the
--- output.
 
-countLines :: String -> String
+  m >> k = m >>= \_ -> k
-countLines = show . length . lines
+  fail s = error s
 
-main' = interact countLines
+{- Como exemplo, a função le_imprime opera com a função ">=" da
+   classe mônada, a qual repassa o retorno obtido com a função
+   getLine para uma função lambda \e qualquer.
 
--- You can think of a value of type `IO ()` as representing a
+   GHC-BASICS
--- sequence of actions for the computer to do, much like a
+   Cria um arquivo chamado le_imprime.hs
--- computer program written in an imperative language. We can use
+   compile: ghc --make -c -O Programa_Haskell_Principal.hs
--- the `do` notation to chain actions together. For example:
+   execute: ./Programa_Haskell_Principal
+-}
 
-sayHello :: IO ()
+le_imprime :: IO ()
-sayHello = do
+le_imprime = getLine >>= \e -> putStrLn e -- le_imprime = getLine >>= putStrLn
-   putStrLn "What is your name?"
-   name <- getLine -- this gets a line and gives it the name "name"
-   putStrLn $ "Hello, " ++ name
 
--- Exercise: write your own version of `interact` that only reads
+{- Mônadas abrem a possibilidade de criar computações
---           one line of input.
+   no estilo imperativo dentro de um grande programa funcional
 
--- The code in `sayHello` will never be executed, however. The only
+   Leis das Mônadas:
--- action that ever gets executed is the value of `main`.
--- To run `sayHello` comment out the above definition of `main`
--- and replace it with:
---   main = sayHello
 
--- Let's understand better how the function `getLine` we just
+   1. return a >>= k  =  k a
--- used works. Its type is:
+   2. m >>= return  =  m
---    getLine :: IO String
+   3. m >>= (\x -> k x >>= h)  =  (m >>= k) >>= h
--- You can think of a value of type `IO a` as representing a
+-}
--- computer program that will generate a value of type `a`
--- when executed (in addition to anything else it does). We can
--- store and reuse this value using `<-`. We can also
--- make our own action of type `IO String`:
 
-action :: IO String
+-- O operador >> é chamada então (p -> q, p então q)
-action = do
+let m >> n = m >>= \_ -> n
-   putStrLn "This is a line. Duh"
-   input1 <- getLine
-   input2 <- getLine
-   -- The type of the `do` statement is that of its last line.
-   -- `return` is not a keyword, but merely a function
-   return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
 
--- We can use this just like we used `getLine`:
+
+----------------------------------------------------
+-- 9. Haskell Entrada/Saída
+----------------------------------------------------
+
+{- Quando um programa Haskell é executado a função `main` é
+   chamada. E ela precisa retornar um valor do tipo IO().
+-}
+
+module Main where
+  main :: IO ()
+  main = putStrLn $ "Oi Glasgow!"
+
+-- Ou simplesmente:
+
+main = putStrLn $ "Oi Glasgow!"
+
+{- putStrLn é do tipo String -> IO()
+
+   É o jeito mais fácil de conseguir E/S se você implementar
+   o seu programa como uma função de String para String.
+
+   A função:
+      interact :: (String -> String) -> IO ()
+   Joga texto, roda a função nela mesma, e imprime a saída
+-}
+
+module Main where
+  contadorLinhas = show . length . lines
+  main = interact contadorLinhas
+
+-- Use a notação `do` para encadear ações. Por exemplo:
+
+diga_oi :: IO ()
+
+diga_oi = do
+
+  putStrLn "Qual eh o seu nome?"
+  name <- getLine
+  putStrLn $ "Oi, " ++ name
+
+main = diga_oi
+
+{- Exercício! Escreva sua própria versão
+   onde irá ler apenas uma linhas de input.
+
+   Vamos entender melhor como `getLine` funciona?
+      getLine :: IO String
+   Pense que o valor do tipo `IO a` representando um
+   programa de computador que irá gerar um valor do tipo `a`
+   quando for ele executado.
+   
+   Nós podemos guardar e reusar isso apenas apontando `<-`.
+   Nós podemos também cria nossas próprias ações do tipo `IO String`
+-}
+
+nova_acao :: IO String
+
+nova_acao = do
+  putStrLn "Uma string curta o bastante."
+  entra1 <- getLine
+  entra2 <- getLine
+  -- return :: String -> IO String
+  return (entra1 ++ "\n" ++ entra2)
+
+{- Nós podemos usar da seguinte maneira
+   como acabamos de usar `getLine`, exemplo:
+-}
 
 main'' = do
-    putStrLn "I will echo two lines!"
+  putStrLn "String A"
   result <- action
   putStrLn result
-    putStrLn "This was all, folks!"
+  putStrLn "String B"
-
--- The type `IO` is an example of a "monad". The way Haskell uses a monad to
--- do IO allows it to be a purely functional language. Any function that
--- interacts with the outside world (i.e. does IO) gets marked as `IO` in its
--- type signature. This lets us reason about what functions are "pure" (don't
--- interact with the outside world or modify state) and what functions aren't.
-
--- This is a powerful feature, because it's easy to run pure functions
--- concurrently; so, concurrency in Haskell is very easy.
-
 
 ----------------------------------------------------
 -- 9. O Haskell REPL (Read Eval Print Loop)
@@ -528,11 +574,6 @@ Prelude> let foo = 1.4
 
 Prelude> :t foo
 foo :: Double
-
-----------------------------------------------------
--- 9. Mônadas
-----------------------------------------------------
-
 ```
 
 
@@ -542,6 +583,7 @@ Compilador e Interpretador Haskell
 
 * [GHC](http://www.haskell.org/ghc/docs/latest/html/users_guide/index.html)
 * [GHC/GHCi](http://www.haskell.org/haskellwiki/GHC)
+* [Haskell em 5 Passos !!!](http://www.haskell.org/haskellwiki/Haskell_in_5_steps)
 
 Instale Haskell [Aqui!](http://www.haskell.org/platform/).
 
@@ -557,6 +599,7 @@ Aplicações Haskell Muito Interessantes:
 
 Comunidade Haskell
 * [Musica das Mônadas](http://www.haskell.org/haskellwiki/Music_of_monads)
+* [Entendendo Mônadas](https://en.wikibooks.org/wiki/Haskell/Understanding_monads)
 
 Tutoriais: