summaryrefslogtreecommitdiffhomepage
path: root/pt-br/haskell-pt.html.markdown
diff options
context:
space:
mode:
Diffstat (limited to 'pt-br/haskell-pt.html.markdown')
-rw-r--r--pt-br/haskell-pt.html.markdown203
1 files changed, 123 insertions, 80 deletions
diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown
index 62cfd76c..6b175408 100644
--- a/pt-br/haskell-pt.html.markdown
+++ b/pt-br/haskell-pt.html.markdown
@@ -402,10 +402,10 @@ foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
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.
-}
@@ -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,
--- it is not hard to explain enough to get going.
-
--- When a Haskell program is executed, the function `main` is
--- called. It must return a value of type `IO ()`. For example:
-
-main :: IO ()
-main = putStrLn $ "Hello, sky! " ++ (say Blue)
--- putStrLn has type String -> IO ()
-
--- It is easiest to do IO if you can implement your program as
--- a function from String to String. The function
--- interact :: (String -> String) -> IO ()
--- inputs some text, runs a function on it, and prints out the
--- output.
-
-countLines :: String -> String
-countLines = show . length . lines
-
-main' = interact countLines
-
--- You can think of a value of type `IO ()` as representing a
--- sequence of actions for the computer to do, much like a
--- computer program written in an imperative language. We can use
--- the `do` notation to chain actions together. For example:
-
-sayHello :: IO ()
-sayHello = do
- 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
--- one line of input.
-
--- The code in `sayHello` will never be executed, however. The only
--- 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
--- used works. Its type is:
--- getLine :: IO String
--- 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
-action = do
- 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`:
+{- As mônadas permitem que o programador construa computações
+ 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.
-main'' = do
- putStrLn "I will echo two lines!"
- result <- action
- putStrLn result
- putStrLn "This was all, folks!"
+ A Classe Mônada padrão em Haskell é a seguinte:
+-}
+
+class Monad m where
+ (>>=) :: m a -> (a -> m b) -> m b
+ (>>) :: m a -> m b -> m b
+ return :: m -> m a
+ fail :: String -> m a
+
+ -- Definição completa mínima:
+ -- (>>=), return
+
+ m >> k = m >>= \_ -> k
+ fail s = error s
+
+{- 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.
+
+ GHC-BASICS
+ Cria um arquivo chamado le_imprime.hs
+ compile: ghc --make -c -O Programa_Haskell_Principal.hs
+ execute: ./Programa_Haskell_Principal
+-}
--- 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.
+le_imprime :: IO ()
+le_imprime = getLine >>= \e -> putStrLn e -- le_imprime = getLine >>= putStrLn
--- This is a powerful feature, because it's easy to run pure functions
--- concurrently; so, concurrency in Haskell is very easy.
+{- Mônadas abrem a possibilidade de criar computações
+ no estilo imperativo dentro de um grande programa funcional
+ Leis das Mônadas:
+
+ 1. return a >>= k = k a
+ 2. m >>= return = m
+ 3. m >>= (\x -> k x >>= h) = (m >>= k) >>= h
+-}
+
+-- O operador >> é chamada então (p -> q, p então q)
+let m >> n = m >>= \_ -> n
+
+
+----------------------------------------------------
+-- 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 "String A"
+ result <- action
+ putStrLn result
+ putStrLn "String B"
----------------------------------------------------
-- 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: