Este é o caminho que recomendo para se aprender Haskell.
#### Uma coisa para se lembrar sempre: *não se preocupe com aquilo que não entender imediatamente*. Apenas continue.
## Comunidade
Nosso canal no IRC é `#haskell-beginners` no Freenode.
Cliente web para IRC [aqui](http://webchat.freenode.net/).
[Listas de e-mails](https://wiki.haskell.org/Mailing_lists) relacionadas a Haskell.
## Diretrizes para a Comunidade
[Leia a postagem de Chris Done sobre ensino](http://chrisdone.com/posts/teaching) (Em inglês)
Seja gentil e cortês. Ser cruel ou rude assusta as pessoas e as desencoraja a participar.
Criticismo barato beneficia apenas a pessoa que o emite, não a pessoa que o recebe.
Não descreva coisas como "fáceis" ou "triviais". Você fará pessoas se sentirem mal por ter que trabalhar duro por progredir naquilo. Pessoas que aprendem lentamente frequentemente são aquelas que aprendem melhor, isso é algo para ser celebrado!
Sem surpresa fingida. Não se faça de surpreso quando alguém diz que não sabe alguma coisa. Essa pessoa se sentirá mal e você terá conseguido nada além de se sentir afiado.
Sem "bom, na verdade". Quando alguém diz algo que está quase - mas não totalmente - correto, e você diz, "bom, na verdade..." e então faz uma correção pequena. Isso é especialmente incômodo quando a correção não tem relação com o assunto conversado. Isso não significa que a Escola de Hackers não é sobre a busca de verdade ou que nós não nos importamos em ser precisos. Quase todos esses "bom, na verdade" são com intenção de se aparecer, não em benefício da verdade.
Sem essa de dirigir no banco de trás. Se você vê as pessoas trabalhando em um problema, você não deveria lançar conselhos intermitentemente. Deixe-as trabalhar a menos que alguém peça por ajuda. Evitar interrupções é [um dos propósitos fundamentais do #haskell-beginners](http://chrisdone.com/posts/teaching)
Sem "-ismos" sutis. Racismo, sexismo, homofobia, transfobia, e outros tipos de preconceito não são bem vindos e não serão tolerados.
- Questão no SO '[Haskell tem otimização de recursão de cauda?](http://stackoverflow.com/questions/13042353/does-haskell-have-tail-recursive-optimization)'
- Slides do [Johan Tibell](https://github.com/tibbe) de uma palestra sobre
[raciociando sobre avaliação preguiçosa](http://www.slideshare.net/tibbe/reasoning-about-laziness).
## Breve demonstração
```haskell
let a = 1 : a -- recursão guardada, (:) é preguiçoso
let (v : _) = a -- e é possível fazer *pattern matching*
> v
1
> head a -- head a == v
1
let a = 1 * a -- recursão não guardada, (*) é estrito
> a
*** Exception: <<loop>>
```
# IO
- [Ordem de avaliação e símbolos de Estado](https://www.fpcomplete.com/user/snoyberg/general-haskell/advanced/evaluation-order-and-state-tokens)
- [Revelando o mistério da IO monad](http://blog.ezyang.com/2011/05/unraveling-the-mystery-of-the-io-monad/).
- ["Afirmações" de primeira classe](http://blog.jle.im/entry/first-class-statements).
- [Haddocks para System.IO.Unsafe.unsafePerformIO](http://hackage.haskell.org/package/base-4.7.0.1/docs/System-IO-Unsafe.html#v:unsafePerformIO)
Leia a documentação e nota de implementação da função `unsagedupableperformio`
Comentário de thread no Reddit por `glaebhoerl`
> Nota importante: o GHC precisa esconder a representação do símbolo de
> estado atrás de um tipo abstrato de IO porque o símbolo de estado sempre
> deve ser usado linearmente (não duplicado ou abandonado), mas o sistema de
> não pode reforçar isso. Clean, uma outra linguagem preguiçosa semelhante a
> Haskell, tem tipos de unicidade (que são como tipos lineares e possivelmente
> diferente em maneiras das quais não estou informado), e eles expõe a "passagem
> do Mundo" diretamente e fornece a monad (não abstrata) apenas por conveniência.
# monads e transformadores de monad (monad transformers)
> Não faça esses até que você entenda typeclasses, Monoid, Functor e Applicative!
Implemente as monads da biblioteca padrão ( List, Maybe, Cont, Error, Reader,
Writer, State ) por si mesmo para entendê-las melhor. Então talvez escreva um
interpretador monádico para uma pequena linguagem de expressões usando o artigo
[Passo-a-passo em Monad Transformers](http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf)
(mencionado abaixo em 'monad trabsformers').
Escrever vários interpretadores apenas mudando a *monad* para mudar a semântica
pode ajudar a entender o que está acontecendo.
- [Esta palestra](https://vimeo.com/73648150) feita pelo Tony motiva de maneira
excelente o uso de *monad transformers*. [Os slides](https://dl.dropboxusercontent.com/u/7810909/talks/monad-transformers/cbaa991e0eb49224eb286c1e418e2b9828e1fb21/monad-transformers.pdf).
Além disso, reimplemente `Control.Monad`. Funções como `mapM` ou `sequence` são boas
oportunidades para praticar escrevendo código monádico genérico.
O curso NICTA pode ser usado como um guia para esse processo, o que também vai
envolver escrever seu próprio *Applicative*.
Créditos:
- comentário no Reddit feito por htmltyp e Crandom [aqui](http://www.reddit.com/r/haskell/comments/29eke6/basic_program_ideas_for_learning_about_monads/cik5aj6).
- comentário no Reddit feito por jozefg [aqui](http://www.reddit.com/r/haskell/comments/29eke6/basic_program_ideas_for_learning_about_monads/cik5trg).
## Monad Transformers
- [Uma introdução gentil a Monad Transformers](https://github.com/kqr/gists/blob/master/articles/gentle-introduction-monad-transformers.md).
- [passo-a-passo em Monad transformers] (http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf) (Aviso! Código desatualizado).
# Testando, testes, especificações, teste de propriedades/generativo
- Este [tutorial](https://github.com/kazu-yamamoto/unit-test-example/blob/master/markdown/en/tutorial.md) por Kazu Yamamoto é fantástico.
- [Simple-Conduit](https://github.com/jwiegley/simple-conduit): Biblioteca simples e boa
para aprender como funciona *streaming IO* em geral, conhecimento transferível
para biliotecas como Pipes e Conduit.
# Parsing em Haskell
- [Tutorial](https://github.com/JakeWheat/intro_to_parsing) em parser combinators
para Haskell usando a Parsec
- [Escrevendo a sua própria micro-parsec](http://olenhad.me/articles/monadic-parsers/)
## Parsing e geração de JSON
Aeson é a solução padrão para parsing de [JSON](https://json.org) em Haskell.
Disponível no [hackage](https://hackage.haskell.org/package/aeson) e
[github](https://github.com/bos/aeson).
- [Fazendo parsing de JSON usando a Aeson](http://blog.raynes.me/blog/2012/11/27/easy-json-parsing-in-haskell-with-aeson/)
- [Aeson tipos criados pelo usuário](http://bitemyapp.com/posts/2014-04-11-aeson-and-user-created-types.html)
- [Fazendo o parsing de dados não-determinísticos com a aeson tipos de soma](http://bitemyapp.com/posts/2014-04-17-parsing-nondeterministic-data-with-aeson-and-sum-types.html)
- O [pacote fgl](https://hackage.haskell.org/package/fgl) particularmente o
caminho mais curto puramente funcionamente [algos](http://hackage.haskell.org/package/fgl-5.4.2.2/docs/Data-Graph-Inductive-Query-SP.html).
- [Grafos Indutivos e Algoritmos de Grafos Funcionais](http://web.engr.oregonstate.edu/~erwig/papers/abstracts.html#JFP01).
- [FGL/Haskell - Uma Biblioteca de Grafos Funcional](http://web.engr.oregonstate.edu/~erwig/fgl/haskell/old/fgl0103.pdf).
- [Código fonte da Data.Graph do pacote Containers](http://hackage.haskell.org/package/containers-0.5.5.1/docs/Data-Graph.html).
- O [pacote graphs](https://hackage.haskell.org/package/graphs).
- [Pergunta no SO sobre PHOAS](http://stackoverflow.com/questions/24369954/separate-positive-and-negative-occurrences-of-phoas-variables-in-presence-of-rec)
- [PHOAS de brinde](https://www.fpcomplete.com/user/edwardk/phoas).
- [Amarrando o nó](http://www.haskell.org/haskellwiki/Tying_the_Knot).
