Não descreva coisas como "fáceis" ou "triviais". Você fará pessoas se sentirem mal por terem que trabalhar duro para progredirem. 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 o Recurse Center 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.
---
Diretrizes do [manual do Recurse Center](https://www.recurse.com/manual).
Se você não sabe nada sobre Stack e gostaria de uma visão geral, confira o [tutorial em video sobre Stack](https://www.youtube.com/watch?v=sRonIB8ZStw).
- 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
[raciocinando 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 transformers').
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 bibliotecas 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 funcional, o [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).
- [Introdução ao GHCJS](http://weblog.luite.com/wordpress/?p=14)
- [Interfaces Web Funcionais e Reativas com GHCJS e Sodium](http://weblog.luite.com/wordpress/?p=127)
- [Escrevendo plugins para o Atom em Haskell usando ghcjs](http://edsko.net/2015/02/14/atom-haskell/)
* [PureScript](http://www.purescript.org/)
- Não é estritamente Haskell como o Haste e o GHCJS, mas é uma escolha
popular entre os Haskellers
- Escrito em e inspirado pelo Haskell
- Experimente o purescript em seu navegador [aqui](http://try.purescript.org/)
- Ótimo guia para [começar](http://www.christopherbiscardi.com/2014/06/22/getting-started-with-purescript/)
## Qual linguagem *frontend* eu deveria usar?
GHCJS e Haste são ambos totalmente Haskell. O GHCJS vai funcionar com mais
pacotes Haskell do que o Haste, mas isso não influencia muitos projetos de
*frontend*. Purescript sequer é Haskell, então compartilhamento direto de
código com seu backend não vai funcionar.
O custo em tempo de execução do GHC é o mais caro próximo dos 10KB (luite está trabalhando nisso). O Haste e o PureScript são competitivos.
O PureScript tem a melhor integração com as ferramentas JavaScript (ele usa gulp/grunt/bower), o GHCJS e o Haste se integram melhor com as ferramentas Haskell (Cabal).
Todos os três são ótimas escolhas e vão funcionar bem para a maior parte dos projetos de *frontend*.
# Para um entendimento mais completo sobre avaliação preguiçosa, NF, WHNF
- [Notas sobre cálculo lambda](https://vec.io/posts/notes-on-lambda-calculus).
## Artigos de pesquisa sobre cálculo lambda preguiçoso
- [Um cálculo lambda com chamada por necessidade](http://homepages.inf.ed.ac.uk/wadler/topics/call-by-need.html#need-journal).
- [Demonstrando Redução em Cálculo Lambda](http://www.itu.dk/~sestoft/papers/sestoft-lamreduce.pdf)
- [Questão no SO: Lendo o GHC Core](http://stackoverflow.com/questions/6121146/reading-ghc-core).
- [Haskell tão rápido quanto C](http://donsbot.wordpress.com/2008/06/04/haskell-as-fast-as-c-working-at-a-high-altitude-for-low-level-performance/).
- [Real World Haskell, Capítulo 25: Perfilação e Otimização](http://book.realworldhaskell.org/read/profiling-and-optimization.html).
# Teorias dos Tipos e das Categorias
> *Não é* necessário saber isso para programar em Haskell, é apenas para
quem se interessar!
Se você quiser um material complementar em teoria dos tipos e das categorias:
- [Guia do Catster](http://byorgey.wordpress.com/2014/01/14/catsters-guide/) e
[Guia do Catster - 2](http://byorgey.wordpress.com/catsters-guide-2/)
- O [wikibook haskell](http://en.wikibooks.org/wiki/Haskell/Category_theory)
tem bons diagramas
- [Teoria das Categorias](http://www.haskell.org/haskellwiki/Category_theory) no
haskellwiki, também tem bons links para outros materiais
- [Categorias do zero](http://science.raphael.poss.name/categories-from-scratch.html), inclui alguns exemplos práticos.
- Lista de [Grandes Trabalhos em LP](http://www.cis.upenn.edu/~bcpierce/courses/670Fall04/GreatWorksInPL.shtml) do Pierce.
## Livros
- [Questão no Quora: Qual o melhor livro-texto para teoria das Categorias?](http://www.quora.com/Category-Theory/What-is-the-best-textbook-for-Category-theory?share=1)
Recomendações do Kmett
- [Awodey](http://ukcatalogue.oup.com/product/9780199237180.do) e
- [GADTs em Haskell 98](http://martijn.van.steenbergen.nl/journal/2009/11/12/gadts-in-haskell-98/).
- [Cálculo Lambda Linear Tipado Tagless-Final](https://www.fpcomplete.com/user/mutjida/typed-tagless-final-linear-lambda-calculus).
- [Interpretação de tagless-final tipado: Notas de Aula](http://okmij.org/ftp/tagless-final/course/course.html).
- [Interpretadores Tagless Final Tipado](http://okmij.org/ftp/tagless-final/course/lecture.pdf).
- [O cachorro que não latia](http://existentialtype.wordpress.com/2011/03/21/the-dog-that-didnt-bark/)
menos especificamente relevante, mas interessante.
## Comonads
- [Comonads em Haskell](https://speakerdeck.com/dmoverton/comonads-in-haskell).
- [Questão no SO: Uma *monad* pode ser uma *comonad*?](http://stackoverflow.com/questions/16551734/can-a-monad-be-a-comonad).
## Yoneda / CoYoneda
- [Questão no SO: Explicação passo-a-passo de coyoneda](http://stackoverflow.com/questions/24000465/step-by-step-deep-explain-the-power-of-coyoneda-preferably-in-scala-throu).
- *Free monads for Less*, uma sequência de três artigos por Edward Kmett.
- [Questão no StackExchange: Qual a diferença entre proposições e julgamentos?](http://cstheory.stackexchange.com/questions/9826/what-is-the-difference-between-propositions-and-judgments).
- [Notas de aula de um curso curto, de três aulas](http://www.ae-info.org/attach/User/Martin-L%C3%B6f_Per/OtherInformation/article.pdf)
# Tipagem dependente
- [Entendendo tipos de soma, construtores de valor, e construtores de tipo](http://bitemyapp.com/posts/2014-04-05-grokking-sums-and-constructors.html) difícil de deixar vesgo.
- [Programação dependente de tipos leve](http://okmij.org/ftp/Computation/lightweight-dependent-typing.html).
- [Linguagem de Programação Idris](http://www.idris-lang.org/).
- [Linkando Estaticamente binários do Linux para ARM & MIPS](http://stackoverflow.com/questions/14270177/ghc-statically-linking-linux-binaries-for-arm-mips-processors)
