diff options
Diffstat (limited to 'pt-br/haskell-pt.html.markdown')
| -rw-r--r-- | pt-br/haskell-pt.html.markdown | 620 |
1 files changed, 620 insertions, 0 deletions
diff --git a/pt-br/haskell-pt.html.markdown b/pt-br/haskell-pt.html.markdown new file mode 100644 index 00000000..788dc1d2 --- /dev/null +++ b/pt-br/haskell-pt.html.markdown @@ -0,0 +1,620 @@ +--- +language: Haskell +contributors: + - ["Adit Bhargava", "http://adit.io"] +translators: + - ["Lucas Tonussi", "http://www.inf.ufsc.br/~tonussi/"] +lang: pt-br +filename: learnhaskell-pt.hs +--- + +As linguagens funcionais são linguagens de programação com base em avaliação +de funções matemáticas (expressões), evitando-se o conceito de mudança de +estado com alteração de dados. Neste aspecto, este paradigma é oposto ao +paradigma imperativo que se baseia em alterações de estados. + +A programação funcional começou no cálculo lambda, que foi base teórica para +o desenvolvimento deste paradigma de programação. + + +```haskell +-- Para comentar a linha basta dois traços seguidos. + +{- Abre chaves traço e traço fecha chaves cria um campo + para comentário em múltiplas linhas. +-} + +---------------------------------------------------- +-- 1. Tipos Primitivos de Dados e Operadores +---------------------------------------------------- + +-- Numerais + +0 -- 3 +1 -- 1 +2 -- 2 ... + +-- Alguns Operadores Fundamentais + +7 + 7 -- 7 mais 7 +7 - 7 -- 7 menos 7 +7 * 7 -- 7 vezes 7 +7 / 7 -- 7 dividido por 7 + +-- Divisões não são inteiras, são fracionádas por padrão da linguagem +28736 / 82374 -- 0.3488479374559934 + + +-- Divisão inteira +82374 `div` 28736 -- 2 + +-- Divisão modular +82374 `mod` 28736 -- 24902 + +-- Booleanos como tipo primitivo de dado +True -- Verdadeiro +False -- Falso + +-- Operadores unitário +not True -- Nega uma verdade +not False -- Nega uma falácia + + +-- Operadores binários +7 == 7 -- 7 é igual a 7 ? +7 /= 7 -- 7 é diferente de 7 ? +7 < 7 -- 7 é menor que 7 ? +7 > 7 -- 7 é maior que 7 ? + + +{- Haskell é uma linguagem que tem uma sintáxe bastante familiar na + matemática, por exemplo em chamadas de funções você tem: + + NomeFunção ArgumentoA ArgumentoB ArgumentoC ... +-} + +-- Strings e Caractéres +"Texto entre abre áspas e fecha áspas define uma string" +'a' -- Caractere +'A' -- Caractere + +'Strings entre aspas simples sobe um erro' -- Erro léxico! + +-- Concatenação de Strings +"StringA" ++ "StringB" -- "StringAStringB" + +-- Concatenação de Caracteres +"haskell" == ['h','a','s','k','e','l','l'] -- True +"haskell" == 'h':'a':'s':'k':'e':'l':'l':[] -- True + +-- Você pode listar uma string pelos seus caractéres +"AbBbbcAbbcbBbcbcb" !! 0 -- 'A' +"AbBbbcAbbcbBbcbcb" !! 1 -- 'b' +"AbBbbcAbbcbBbcbcb" !! 2 -- 'B' + +---------------------------------------------------- +-- Listas e Túplas +---------------------------------------------------- + +-- A construção de uma lista precisa ser de elementos homogêneos +[1, 2, 3, 4, 5] -- Homogênea +[1, a, 2, b, 3] -- Heterogênea (Erro) + +-- Haskell permite que você crie sequências +[1..5] + +{- Haskell usa avaliação preguiçosa o que + permite você ter listas "infinitas". +-} + +-- Uma lista "infinita" cuja razão é 1 +[1..] + +-- O 777º elemento de uma lista de razão 1 +[1..] !! 777 -- 778 + +-- União de listas [lista_0] ++ [lista_1] ++ [lista_i] +[1..5] ++ [6..10] ++ [1..4] -- [1,2,3,4,5,6,7,8,9,10,1,2,3,4] + +-- Adiciona um cabeçalho a sua lista e desloca a cauda +0:[1..10] -- [0, 1, 2, 3, 4, 5] +'a':['a'..'e'] -- "aabcde" + +-- Indexação em uma lista +[0..] !! 5 -- 5 + +-- Operadores de Listas usuais +head ['a'..'e'] -- Qual o cabeçalho da lista ? +tail ['a'..'e'] -- Qual a cauda da lista ? +init ['a'..'e'] -- Qual a lista menos o último elemento ? +last ['a'..'e'] -- Qual o último elemento ? + +-- Compreensão de Lista (List Comprehension) + +{- Uma lista pode ser especificada + pela definição de eus elementos. + A compreensão de listas é feita + com um construtor de listas que + utiliza conceitos e notações + da teoria dos conjuntos. + + Exemplo: + + A = { x**2 | X pertence aos Naturais && x é par} +-} + +let par x = mod x 2 == 0 +let constroi_lista = [x * x | x <- [9 ..39], par x] +-- [100,144,196,256,324,400,484,576,676,784,900,1024,1156,1296,1444] + +par 4 -- True +par 3 -- False + + +-- Listas com regras +{- Para todo x se x é elemento da lista + faça 2 vezes x mas componha a lista + com apenas aqueles elementos cujo + 2*x é maior que 4 +-} +[x*2 | x <- [1..5], x*2 > 4] -- [6, 8, 10] + +-- Tuplas +("Q", "Gamma", "b", "Sigma", "delta", "q0", "F") -- 7-Tuple Turing Machine + +-- Retirando da tupla + +{- Com as funções fst (primeiro) e snd (segundo) + você só pode enviar por parâmetro uma tupla + bi-dimensional ou seja, 2 dimensões == (x,y) +-} + +fst ((2,3), [2,3]) -- (2,3) +snd ((2,3), [4,3]) -- [4,3] + + +---------------------------------------------------- +-- 3. Funções em Haskell +---------------------------------------------------- + +-- Uma função simples que toma duas variáveis +{- Haskell trabalha em cima de recursão + Portanto certifique-se que você + Entende como recurssão funciona. +-} + +soma a b = a + b -- Função que vai em um programa.hs + +{- Dentro do GHCi (Interpretador Haskell) + Você terá que fazer da seguinte maneira-- Podemos criar nos + + Prelude> let soma a b = a + b + Prelude> soma 7 7 -- 14 +-} + +let constroi_lista = [x * x | x <- [9 ..39], par x] + +{- Você pode usar crases para chamar + Funcões de maneira diferente +-} + +7 `soma` 7 -- 14 + +{- Haskell permite que você crie os + seus próprios operadores baseados + nos já existendes +-} + +let (~/\) a b = a `mod` b +15^13 ~/\ 432 -- 759375 + +-- Casamento de Padrões em Tuplas +coordenadas (x, y) = (x + 13, y - 31) + +{- Haskell trabalha com casamento de padrões onde dada + um conjunto de funções definidas de diferentes maneiras + Haskell vai procurar por aquela que trabalha o seu tipo + de entrada. +-} + +-- Guardas "|" É um jeito simples de representar funções recursivas + +let fatorial n | n == 0 = 1 | otherwise = fatorial (n - 1) * n -- Teste: fatorial 5 + +-- Ainda podemos fazer: + +let fatorial 0 = 1 +let fatorial n = fatorial (n - 1) * n + +{- Podemos criar nossos próprios Mapeadores + Onde `primeiro` é o primeiro elemento de + uma lista é `resto` é o resto da lista. +-} + +mapa mapeador _ [] = [] +mapa mapeador (primeiro : resto) = mapeador primeiro : (mapa mapeador resto) + +{- 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. +-} + +(\x -> x + 1) 4 -- 5 + + +{- 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` +-} + +-- 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 +---------------------------------------------------- + +{- Currying: Se você não passar todos os argumentos + para uma função, ela irá ser "currificada". O que + significa que irá retornar a função que pega o resto + dos elementos. +-} + +soma a b = a + b +foo = soma 10 -- foo ganha a propriedade "currying" +foo 5 -- 15 + +-- Outra maneira +foo = (+10) +foo 5 -- 15 + +{- Composição de Funções + O (.) encadeia funções! Por exemplo, + aqui foo é uma função que recebe um valor. + Ela soma 10 a ela, multiplica o resultado por 5 + e então retorna o resultado final. +-} +foo = (*5) . (+10) + +-- (5 + 10) * 5 = 75 +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 . Você pode usar `.` e `$` para se livrar + de parentízação desnecessária. +-} + +(even (fatorial 3)) -- true + +-- Usando `.` e `$` +even . fatorial $ 3 -- true + +---------------------------------------------------- +-- 5. Tipos +---------------------------------------------------- + +-- Haskell é fortemente tipado e tudo tem uma assinatura típica. + +-- Tipos Básicos: +460 :: Integer +"music" :: String +True :: Bool + +{- Funções também tem tipos. + `not` recebe um booleano e retorna um booleano: + not :: Bool -> Bool +-} + +{- Aqui temos uma função que recebe dois argumentos + soma :: Integer -> Integer -> Integer +-} + +{- Quando você define um valor em Haskell + uma boa prática de programação é escrever + o TIPO acima dessa mesma. Como segue: +-} + +double :: Integer -> Integer +double x = x * 2 + +---------------------------------------------------- +-- 6. Controle de Fluxo e IF-THEN-ELSE +---------------------------------------------------- + +-- Blocos IF-THEN-ELSE +let valor_alternado = if 144 `mod` 6 == 4 then "acertou" else "errou" -- errou + +-- É legal identar quando você tem múltiplos branchs para acontecer + +let valor_alternado = if 144 `mod` 6 == 4 + then "acertou" + else "errou" + +-- Blocos CASE + +{- caso <argumento> seja : + <ajuda> -> mostra_ajuda + <inicia> -> inicia_programa + <_> -> putStrLn "ExArgumentoInvalido" + + Onde `_` Significa Qualquer Outra Coisa. +-} + + +case args of + "ajuda" -> mostra_ajuda + "inicia" -> inicia_programa + _ -> putStrLn "ExArgumentoInvalido" + +{- 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] + +-- Você pode criar um FOR-LOOP usando map +let for array funcao = map funcao array +for [0..5] $ \i -> show i + +-- Ou ainda (Pesquise sobre show em Haskell): +for [0..5] show + + +{- 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 + +-- Pensando Recursivamente Esquerda-Direita +(2 * (2 * (2 * 4 + 1) + 2) + 3) -- 43 + +-- Fold Right +foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16 + +-- Pensando Recursivamente Direita-Esquerda +(2 * 3 + (2 * 2 + (2 * 1 + 4))) + +---------------------------------------------------- +-- 7. Declaração de Dados +---------------------------------------------------- + +{- 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. +-} + +data Cor = Vermelho | Azul | Verde + +-- say :: Color -> String + +let say Vermelho = "Vermelho" +let say Azul = "Azul" +let say Verde = "Verde" + +{- 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 + +-- 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. Mônadas +---------------------------------------------------- + +{- 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. + + 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 +-} + +le_imprime :: IO () +le_imprime = getLine >>= \e -> putStrLn e -- le_imprime = getLine >>= putStrLn + +{- 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) +---------------------------------------------------- + +{- Digite dhci no seu terminal + para começar o interpretador + lembre-se que para definir + funções e variáveis em haskell + pelo interpretador você precisar + iniciar com `let` +-} + +Prelude> let foo = 1.4 + +-- Você pode ver o tipo de algo usando `:t`: + +Prelude> :t foo +foo :: Double +``` + + +# Extra + +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/). + +Aplicações Haskell Muito Interessantes: + +* [Música e Som](http://www.haskell.org/haskellwiki/Applications_and_libraries/Music_and_sound) +* [Haskell SuperCollider Servidor](https://github.com/kaoskorobase/hsc3-server) +* [Haskell SuperCollider Cliente](http://hackage.haskell.org/package/hsc3) +* [Física e Matemática](http://www.haskell.org/haskellwiki/Applications_and_libraries/Mathematics) +* [Jogos](http://www.haskell.org/haskellwiki/Applications_and_libraries/Games) +* [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) +* [Entendendo Mônadas](https://en.wikibooks.org/wiki/Haskell/Understanding_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) + +Leia Sobre As Mônadas [Aqui!](http://www.haskell.org/haskellwiki/Monads) + +Livro: Haskell Uma Abordagem Prática - Claudio Cesar de Sá e Márcio Ferreira da Silva |