Home
 

Aperitivos de Haskell - 24 dias de Hackage, 2015 - dia 1 - Introdução e Stack

por Franklin Chen

traduzido por Pedro Yamada

Esse é um artigo escrito por Franklin Chen e traduzido para o português. Ler original.

Nessa série de posts traduzidos “24 dias de Hackage, 2015”, caminhamos por uma série de módulos publicados no ecossistema da linguagem de programação Haskell. Pacotes bonitos, surpreendentes ou simplesmente muito úteis para o uso de Haskell na vida real.

Índice de toda a série

Dia 1

Alguns dias atrás, eu me deparei com um tweet do Ollie Charles sobre como ele não teve tempo de fazer seus posts de usuais em dezembro “24 dias de…” esse ano. Fiquei triste porque eu aprendi muito lendo eles. Tanto em 2012 quanto em 2013, ele escreveu “24 dias de Hackage”, pequenos e úteis posts que mostravam como usar alguns pacotes selecionados que você pode obter pelo arquivo comunitário Hackage e, em 2014, ele cobriu extensões da linguagem no GHC.

Com alguma trepidação, decidi que eu faria uma série “24 dias de Hackage” para terminar o ano dividindo uma seleção do enorme número de pacotes de Haskell que acho úteis. Eu achei que seria particularmente apropriado fazer isso dado que 2015 foi o ano em que eu migrei para usar Haskell como minha linguagem principal na maior parte do meu trabalho recente e projetos pessoais e, assim, esse foi um ano de descobertas consideráveis para mim.

Todo o código

Todo o código para a série estará nesse repositório do GitHub.

Meu critério de seleção

Como escolher o quê cobrir? Eu gosto do que Ollie escreveu em seu post inaugural de 2012:

Esse será um tour turbulento de alguns módulos que eu uso em uma base (quase) diária, incluindo módulos que me inspiraram, módulos que mudam a forma como penso sobre código, e alguns módulos que são tão incríveis que eu não sou inteligente o suficiente para os usar!

Minha intenção: algumas coisas que vou cobrir já são populares e conhecidas, algumas podem só ser utilitários pequenos, algumas podem ser completamente obscuras, mas o tema fundamental será “coisas que eu uso e sobre as quais posso dizer algo útil brevemente”.

Stack

Foi muito fácil escolher o tópico para o primeiro dia: Stack, a maior nova coisa para Haskell em 2015 fora o GHC 7.10.

Stack mudou minha vida (com Haskell).

Stack é um game changer para a comunidade Haskell. É uma solução all-in-one para criar projetos Haskell, manejar dependências, compilar e mais. Desde que o Stack foi publicado, eu tenho lentamente migrado projetos antigos para o usa-lo, e eu uso o Stack para todos os novos projetos, incluindo o repositório para essa série

Eu não vou dar um tutorial completo no Stack aqui hoje, só um gostinho, e você pode ler a documentação oficial para detalhes, mas o que eu gostaria de enfatizar é que o Stack é útil não só para desenvolvedores experientes, mas especialmente para recem-chegados, então parte do artigo de hoje é destinado especificamente para recem-chegados (ou aqueles que tentaram Haskell e estão interessados em um recomeço com ferramentas melhores).

“Como eu começo com Haskell”?

Quando eu comecei o Pittsburgh Haskell em Fevereiro desse ano (2015), eu encontrei uma dificuldade enorme: ajudar recem-chegados a Haskell a começar. Eu criei uma sessão de workshop introdutória, mas uma quantidade enorme de pessoas se desencorajaram pela minha melhor tentativa de criar um agora obsoleto guia de instalação para Haskell que funcionaria no OSX, Windows e Linux, e as pessoas tiveram problemas instalando as ferramentas básicas, e problemas de versão se já tivessem uma versão antiga do GHC instalada. Muito tempo foi desperdiçado em tentar ajudar as pessoas com a instalação.

Pittsburgh Haskell deixou de estar ativo em Abril, já que fiquei ocupado com muitas outras coisas e não havia momento no tempo para o manter andando, mas eu acredito que um problema grande em tentar criar uma nova comunidade de Haskell local foi a irritação com ferramentas e setup.

Stack resolve esse problema. Se eu desse um workshop introdutório a Haskell de novo, eu definitivamente usaria o Stack.

Um exemplo de começar a usar o Stack usando um template customizado

Se você ainda não usa o Stack, baixe ele.

O Web site do Stack já tem a documentação de como começar a usar o Stack usando o template default. Aqui, eu quero promover a ideia de usar e dividir templates customizados. Isso não é bem documentado, mas eu acho que vai ser mais e mais importante para recem-chegados, e claro que também é útil para qualquer um de nós que sempre criamos o mesmo boilerplate para configurar um novo projeto.

Usando um template oficial

Eu criei um template customizado chamado franklinchen que é parte do repositório oficial stack-templates.

Se você executar

$ stack new stack-template-demo franklinchen

Prompts aparecerão pedindo a informação para criar um novo projeto chamado stack-template-demo.

Usando seu próprio template local

Note que o template especificado não tem que estar no repositório oficial stack-templates. Ele também pode estar no seu file system local. Por exemplo, antes de eu enviar meu template para stack-templates, eu costumava rodar:

$ stack new stack-template-demo /path/on/my/computer/to/franklinchen.hsfiles

onde franklinchen.hsfiles é o meu template (leia abaixo sobre como criar seu próprio template).

(Eu botei uma instância do projeto gerado no GitHub, caso você queira olhar na estrutura sem ter que instalar e rodar o Stack agora.)

Começando com o novo projeto gerado

Entre no diretório do projeto:

$ cd stack-template-demo

O Stack baixo o GHC para você

Rode

$ stack setup

Se você ainda não tem uma versão apropriada do GHC instalada, o Stack vai automaticamente baixar e instalar ela pra você, em uma área do diretório de configuração do Stack ~/.stack. A coisa importante a se notar é que quando usando o Stack, muitas versões do GHC podem coexistir como desejado para muitas configurações de compilação diferentes e setups. Essa feature é muito importante, porque nem todo mundo usa a mesma versão do GHC e você pode compilar seu projeto usando muitas versões do compilador facilmente.

Essa feature de download automático é particularmente útil para recem-chegados que não precisam ficar mexendo com uma instalação global separada que requira privilégios especiais.

No output, se o Stack precisar baixar alguma coisa:

Preparing to install GHC to an isolated location.
This will not interfere with any system-level installation.
Downloaded ghc-7.10.2.
Installed GHC.
stack will use a locally installed GHC
For more information on paths, see 'stack path' and 'stack exec env'
To use this GHC and packages outside of a project, consider using:
stack ghc, stack ghci, stack runghc, or stack exec

Executando o REPL GHCi

A coisa mais importante para um recem-chegado a Haskell é começar com o REPL GHCi, então vamos fazer isso agora. Fazer isso no contexto de um projeto carregando seus módulos é simples com o Stack.

Rode:

$ stack ghci

Note que somente da primeira vez que você fizer isso (ou outros comandos que precisem de dependências), Stack pode demorar um pouco para baixar e compilar elas. As dependências acabam instaladas e botadas em um cache para que outros projetos no futuro possam as usar de novo. Essa é uma vantagem enorme do Stack versus os dias antes do Stack, onde nós sempre tínhamos o problema de re-baixar e re-compilar as mesmas bibliotecas para projetos diferentes; isso era um desperdício enorme de tempo e espaço! Stack decide inteligentemente o que pode ou não ser dividido consistentemente.

Stack executa um REPL GHCi com nossos módulos carregados:

Ok, modules loaded: Lib, Main.

In src/Lib.hs no projeto de exemplo, nós temos um módulo besta ilustrando um pouco os comentários de documentação Haddock:

-- | A library to do stuff.
module Lib
    (
      ourAdd
    ) where

-- | Add two 'Int' values.
ourAdd :: Int  -- ^ left
       -> Int  -- ^ right
       -> Int  -- ^ sum
ourAdd x y = x + y

Nós podemos acessar o módulo Lib do REPL:

*Main> ourAdd 2 3
5
*Main> Lib.ourAdd 4 5
9

Nós também podemos acessar Main, que é definido em app/Main.hs:

module Main where

import Lib (ourAdd)

import Text.Printf (printf)

main :: IO ()
main = printf "2 + 3 = %d\n" (ourAdd 2 3)
*Main> main
2 + 3 = 5

Compilando e rodando o projeto

Você poderia ter compilado o projeto explicitamente primeiro, antes de executar o REPL. Na prática em projetos reais, eu começo compilando um projeto para compilar suas dependências, antes de usar o GHCi, apesar de que o que fiz acima faz isso para você também:

$ stack build

Porque defini um binário executável nativo chamado stack-template-demo no nosso arquivo Cabal stack-template-demo.cabal, podemos rodar o executável:

$ stack exec stack-template-demo
2 + 3 = 5

Eu incluí testes unitários para Lib em test/LibSpec.hs que podem ser rodados com:

$ stack test
Lib
  Lib
    works
    ourAdd is commutative

Finished in 0.0007 seconds
2 examples, 0 failures

Instalando a biblioteca e executável

Você pode agora instalar a biblioteca e executável para seu próprio uso mais tarde:

$ stack install
...
...
Copying from /Users/chen/stack-template-demo/.stack-work/install/x86_64-osx/lts-3.16/7.10.2/bin/stack-template-demo to /Users/chen/.local/bin/stack-template-demo

Copied executables to /Users/chen/.local/bin:
- stack-template-demo

Por exemplo (já que ~/.local/bin está no meu PATH):

$ stack-template-demo
2 + 3 = 5

Sua própria configuração para templates do Stack

Ao usar templates do Stack, é útil adicionar sua informação para a configuração global, para que ela seja inserida automaticamente quando você gerar projetos novos. A documentação para a configuração está aqui. Crie um arquivo em ~/.stack/config.yaml. O meu tem:

templates:
  params:
    author-email: "franklinchen@franklinchen.com"
    author-name: "Franklin Chen"
    category: test
    copyright: "2015"
    github-username: "FranklinChen"

Outras coisas brilhantes

Eu tento usar o Travis CI para qualquer código que eu publique, então meu template gera um arquivo .travis.yml que usa o Stack. Eu comecei a migrar meus antigos setups do Travis baseados em multi-ghc-travis para usar o Stack.

Criando um template de projeto customizado do Stack

Foi surpreendente para mim que criar um template customizado não é coberto pela documentação principal do Stack. Ao invés disso, eu encontrei como o fazer no repositório stack-templates.

O método de criar templates customizados é um pouco rudimentar, envolvendo criar um único arquivo com diretivas embedadas para indicar os arquivos e estrutura de diretórios criada, mas é um começo.

Conclusão

Para o dia 1 do meu “24 days of Hackage”, eu brevemente introduzi como usar o Stack, a ferramenta de Haskell que estou usando para compilar e rodar todos os exemplos nessa série de artigos.

Em breve: um pouco de código real!

Nota do tradutor

Essa foi uma tradução grossa do primeiro post da série do Franklin Chen. Estou atrasado com seus posts em 8 dias. Poderia só traduzir todos os posts agora e os publicar de uma vez, mas acho que vale mais a pena publicar um post por dia a partir de hoje.

Assim, se você quer acompanhar a série enquanto está fresca, não se esqueça de visitar o blog do Franklin. Esse post será atualizado diáriamente com links para as próximas traduções.

Não vou ter tempo de revisar muito o texto, então se você encontrar um typo, seja gentil e dê um toque. O maior intuito de traduzir essa série é ter os artigos traduzidos para a posterioridade. Quando o final de ano chegar, teremos 24 artigos muito relevantes (obrigado Franklin!), em português.

Se você quer ajudar com esse tipo de coisa, agora é a hora. Entre no Slack ou no IRC da HaskellBR e contribua. Esse blog e outros projetos associados estão na organização haskellbr no GitHub e em haskellbr.com/git.

Share Comente no Twitter