Archives/learnhaskell
2
0
Fork 0
mirror of https://github.com/bitemyapp/learnhaskell.git synced 2024-11-03 23:15:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master'

Browse Source 
merge previous changes and translate "Getting set-up"
Conflicts:
	guide-es.md
This commit is contained in:
oscar_felipe 2015-04-28 23:25:24 +02:00
commit f99e6ff5a5
6 changed files with 1565 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
README.md
View File

@ -17,8 +17,6 @@ This is my recommended path for learning Haskell.
* [Em Português](guide-pt.md)
* [Türkçe](guide-tr.md)
#### Something to keep in mind: *don't sweat the stuff you don't understand immediately*. Just keep moving.
@ -374,7 +372,7 @@ Comment from Reddit thread by `glaebhoerl`
Implement the standard library monads ( List, Maybe, Cont, Error, Reader,
Writer, State ) for yourself to understand them better. Then maybe write an
monadic interpreter for a small expression language using
[Monad Transformers Step by Step](http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf)
[Monad Transformers Step by Step](http://catamorph.de/documents/Transformers.pdf)
paper (mentioned in 'monad transformers' below).
Writing many interpreters by just changing the monad to change the semantics can
@ -399,7 +397,7 @@ Credits:
- [A gentle introduction to Monad Transformers](https://github.com/kqr/gists/blob/master/articles/gentle-introduction-monad-transformers.md).
- [Monad transformers step-by-step](http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf) (warning, code out of date).
- [Monad transformers step-by-step](http://catamorph.de/documents/Transformers.pdf).
# Testing, tests, specs, generative/property testing

6
guide-de.md
View File

@ -410,7 +410,7 @@ Original:
Implementiere die Monaden aus der Standard Bibliothek ( List, Maybe, Cont, Error, Reader,
Writer, State ) für dich selbst, um sie besser zu verstehen. Dann schreibe vielleicht einen
monadischen Interpreter für eine kleine Expression Sprache mit dem
[Monad Transformers Step by Step](http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf)
[Monad Transformers Step by Step](http://catamorph.de/documents/Transformers.pdf)
Paper (erwähnt in 'monad transformers' im folgenden).
Mehrere Interpreter zu schreiben, indem man einfach nur die Monade ändert um die Semantik zu verändern
@ -432,10 +432,10 @@ Credits:
- Reddit Kommentar von jozefg [hier](http://www.reddit.com/r/haskell/comments/29eke6/basic_program_ideas_for_learning_about_monads/cik5trg).
## Monad transformers
- [A gentle introduction to Monad Transformers](https://github.com/kqr/gists/blob/master/articles/gentle-introduction-monad-transformers.md).
- [Monad transformers step-by-step](http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf) (warning, code out of date).
- [Monad transformers step-by-step](http://catamorph.de/documents/Transformers.pdf).
# Testen, Tests, Specs, generative/property testing

8
guide-es.md
View File

@ -18,17 +18,17 @@ La [lista de correo](https://wiki.haskell.org/Mailing_lists) de Haskel.
Se amable y cortés. Ser odioso y rudo ahuyenta a la gente y les desmotiva a participar.
Criticar por el placer de criticar es solo beneficial para las personas que lo practican, no para los que reciben la crítica.
Criticar por el placer de criticar es solo benéfico para las personas que lo practican, no para los que reciben la crítica.
No describas las cosas como "sencillas" o "simples". Vas a hacer sentir a las personas mal por tener que trabajar tan duro por su progreso. Los que aprenden mas lento son generalmente los más meticulosos aprendices, lo cual merece aprobación!
No describas las cosas como "sencillas" o "simples". Vas a hacer sentir a las personas mal por tener que trabajar tan duro por su progreso. Los que aprenden mas lento son generalmente los mas meticulosos aprendices, ¡lo cual merece aprobación!
No simules sorpresa. No actues sorprendido cuando alguien reconoce no saber algo, eso hará sentir terrible a la persona y no obtendras nada excepto hacerte ver sarcástico.
"Mmm...no, de hecho..." Cuando alguien dice algo que es casi pero no completamente correcto y dices, "bueno...no, de hecho..." y luego das una mínima corrección, es especialmente molesto si la corrección que realizas no es lo suficientemente relevante. Esto no significa que al no hacerlo tratamos de ignorar la verdad o que no nos importa ser precisos. El punto es que casi todos los "Mmm... no, de hecho..." son fanfarronerías, no procuradores de la verdad.
No seas el copiloto pesado que siempre esta dando instrucciones al conductior del vehiculo. Si ves a alguien trabajando en un problema, no deberías interrumpir intermitentemente para dar consejo. Dejales trabajar hasta que pidan ayuda. Evitar interrupciones es [uno de los principios fundamentales de #haskell-beginners](http://chrisdone.com/posts/teaching).
No seas el copiloto pesado que siempre esta dando instrucciones al conductior del vehículo.Si ves a alguien trabajando en un problema, no deberías interrumpir intermitentemente para dar consejo. Déjales trabajar hasta que pidan ayuda. Evitar interrupciones es [uno de los principios fundamentales de #haskell-beginners](http://chrisdone.com/posts/teaching).
No uses sutil -ismos. Racismo, sexismo, homofobia, transfobia u otro tipo de prejuicios no son bienvenidos y no serán tolerados.
Ningún sutil -ismo. Racismo, sexismo, homofobia, transfobia u otro tipo de prejuicios no son bienvenidos y no serán tolerados.
---

15
guide-fr.md
View File

@ -274,17 +274,6 @@ la concurrence, les pipes, et les lenses.
---
## Documentation de référence pour les trois cours
[Learn You a Haskell for Great Good (LYAH)](http://learnyouahaskell.com) et
[Real World Haskell](http://book.realworldhaskell.org) (Merci bos !) sont
disponibles en ligne.
Je recommande RWH comme reference (un livre épais). Les chapitres sur le parsing et
les monades sont super pour comprendre où les monades sont utiles. D'autres ont confirmé
qu'il l'avaient beaucoup apprécié. Certainement une bonne suite pour des idiomes plus pratiques
lorsque vous aurez intégré les bases d'Haskell.
### Que sont les sucres syntactiques `<-` / `do` / comprehension de listes ?
Un [article](http://www.haskellforall.com/2014/10/how-to-desugar-haskell-code.html) excellent.
@ -370,7 +359,7 @@ Implémenter les monades de la librairie standard (List, Maybe, Cont, Error,
Reader, Writer, State) par vous-même afin de mieux les comprendre. Après, vous
pouvez peut-être écrire un interpréteur monadique pour un langage avec des petites
expressions en utilisant le papier sur les
[transformateurs de monades étape par étape](http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf)
[transformateurs de monades étape par étape](http://catamorph.de/documents/Transformers.pdf)
(mentionné dans la section "transformateurs de monades" ci-dessous).
Écrire plusieurs interpréteurs en changeant juste le Monde pour changer les
@ -401,7 +390,7 @@ Crédits:
de Kazu Yamamoto est fantastique.
- [Simple-Conduit](https://github.com/jwiegley/simple-conduit): Une bonne librairie simple pour apprendre comment le streaming d'IO fonctionne en général. Les connaissances acquises ici sont transférables à Pipes et Conduit.
# Parsing en Haskell
- [Tutoriel](https://github.com/JakeWheat/intro_to_parsing) sur les parser

742
guide-it.md
View File

@ -0,0 +1,742 @@
# La Guida
Questa è la strada che raccomando per imparare Haskell.
## Per chi non parla italiano
* [Auf Deutsch](guide-de.md)
* [Στην ελληνική](guide-el.md)
* [En Français](guide-fr.md)
* [In English](README.md)
* [Em Português](guide-pt.md)
* [Türkçe](guide-tr.md)
#### Un consiglio: *non preoccupatevi se non capite qualcosa alla prima lettura*. Andate avanti.
## Comunità
Il nostro canale IRC è `#haskell-beginners` su Freenode.
Un client web per IRC è disponibile [qui](http://webchat.freenode.net/).
La [mailing list](https://wiki.haskell.org/Mailing_lists) di Haskell.
### Linee guida per la comunità
[Leggete il post di Chris Done sull'insegnamento](http://chrisdone.com/posts/teaching).
Siate gentili e cortesi. Comportamenti crudeli o meschini spaventano gli altri e fanno passare la voglia di partecipare.
Crtitiche facili, in cui non mettete impegno, beneficiano soltanto voi e non la persona che le riceve.
Non descrivete niente con parole come "facile" o "banale". Chi legge si sentirà stupido perché le cose che definite come triviali possono aver richiesto molto impegno. Spesso chi impara lentamente impara più profondamente, è una cosa che dovremmo perseguire!
Non fate finta di essere sorpresi quando qualcuno vi dice che non sa qualcosa. Lo farete sentire soltanto stupido e non avrete ottenuto niente a parte sentirvi più furbi.
Non dite beh-in realtà. Come quando qualcuno dice che qualcosa è quasi, ma non completamente corretta, e voi cominciate a dire, "beh, in realtà…" e poi fate una piccola correzione. È molto irritante, specialmente quando la correzione non è pertinente alla conversazione che state avendo. Questo non significa che l'Hacker School non si preoccupi della verità o che non ci interessi essere precisi. Ma questi modi di fare sono quasi sempre più una questione di pavoneggiamento che altro.
Non dite agli altri cosa devono fare. Se qualcuno sta completando un esercizio non dovreste interromperlo continuamente con consigli. Lasciate che trovi la sua strada a meno che non lo chieda esplicitamente. Evitare interruzioni è [uno degli obiettivi fondamentali di #haskell-beginners](http://chrisdone.com/posts/teaching).
Non lasciate spazio a sottili "ismi". Razzismo, sessismo, omofobia, transfobia, e altri tipi di pregiudizi non saranno tollerati.
---
Linee guida tratte dal [manuale della Hacker School ](https://www.hackerschool.com/manual). Grazie per averle rese pubbliche.
# Cosa sono Haskell, GHC e Cabal?
Haskell è un linguaggio di programmazione, e come potete leggere nei report, la versione più recente è stata rilasciata nel 2010. Il report è disponibile online:
[report](http://www.haskell.org/onlinereport/haskell2010/).
## GHC
[GHC](http://www.haskell.org/ghc/) è il modo più classico per lavorare in Haskell. Include un compilatore, un REPL (interprete), un gestore automatico di pacchetti e librerie, ed altro.
## Cabal
[Cabal](https://www.haskell.org/cabal/download.html) è software per gestire i progetti haskell e risolvere le dipendenze. È lo strumento che vi permetterà di installare i pacchetti, tipicamente ciascuno nel proprio sandbox.
Cabal è equivalente a Bundler di Ruby, pip di Python, NPM di Node, Maven, etc. GHC
gestisce i pacchetti indipendentemente, Cabal sceglie quale versione installare.
# Il set-up dei tool
## Ubuntu
[Questo PPA](http://launchpad.net/~hvr/+archive/ghc) è ottimo ed è quello che uso su tutte le mie macchine linux, sia per i build automatici che per lo sviluppo.
Istruzioni specifiche:
```bash
$ sudo apt-get update
$ sudo apt-get install python-software-properties # v12.04 and below
$ sudo apt-get install software-properties-common # v12.10 and above
$ sudo add-apt-repository -y ppa:hvr/ghc
$ sudo apt-get update
$ sudo apt-get install cabal-install-1.20 ghc-7.8.3 happy-1.19.4 alex-3.1.3
```
Aggiungete poi la seguente linea al vostro `$PATH` (bash\_profile, zshrc, bashrc, etc):
```
~/.cabal/bin:/opt/cabal/1.20/bin:/opt/ghc/7.8.3/bin:/opt/happy/1.19.4/bin:/opt/alex/3.1.3/bin
```
*Opzionale:* Potete anche aggiungere `.cabal-sandbox/bin` al vostro path. Il codice che state sviluppando attivamente sarà così disponibile dalla linea di comando. Questo funziona solo quando la directory in cui siete è un sandbox di cabal.
## Debian
### Repository GHC per debian stable
Se utilizzate Debian stable, è meglio usare il repository http://deb.haskell.org/. Per usarlo:
- Aggiungete la linea `deb http://deb.haskell.org/stable/ ./` a `/etc/apt/sources.list`
```bash
## Aggiungi la chiave per evitare warning
$ GET http://deb.haskell.org/deb.haskell.org.gpg-key | apt-key add -
$ sudo apt-get update
$ sudo apt-get install ghc-7.8.3 happy alex cabal-install
```
### Usando Ubuntu PPA
Se non state usando Debian stable, le stesse istruzioni che abbiamo indicato per Ubuntu fuzionano, ma dovrete eseguire un comando in più. Immediatamente dopo che il comando
`sudo add-apt-repository -y ppa:hvr/ghc`
lanciate:
```bash
$ sudo sed -i s/jessie/trusty/g /etc/apt/sources.list.d/hvr-ghc-jessie.list
```
Per altre versioni di Debian dovete solo rimpiazzare tutte le occorrenze di `jessie` con il nome della versione che state utilizzando nel comando di cui sopra.
Se per qualche ragione il file `/etc/apt/sources.list.d/hvr-ghc-jessie.list` non dovesse esistere, allora `/etc/apt/sources.list` dovrebbe contenere una linea come questa:
deb http://ppa.launchpad.net/hvr/ghc/ubuntu jessie main
Rimpiazzate quindi in quella linea `jessie` con `trusty`.
### Compilazione manuale
Potete seguire
[questa](http://www.davesquared.net/2014/05/platformless-haskell.html) guida scritta per Mac OS X:
Note:
- Quando configurate ghc settate il prefisso appropriato
- Invece di prendere il binario di `cabal-install`, scaricate il codice sorgente e lanciate lo script
`bootstrap.sh`.
## Fedora 21
Per installare Haskell 7.8.4 dal repository non ufficiale (Fedora 22+ lo includerà ufficialmente):
```bash
$ sudo yum-config-manager --add-repo \
> https://copr.fedoraproject.org/coprs/petersen/ghc-7.8.4/repo/fedora-21/petersen-ghc-7.8.4-fedora-21.repo
$ sudo yum install ghc cabal-install
```
Come affermato in
[petersen/ghc-7.8.4 copr page](https://copr.fedoraproject.org/coprs/petersen/ghc-7.8.4/)
questo ghc non può essere installato insieme con il ghc di Fedora/EPEL.
## Arch Linux
Per installare Haskell dal repository ufficiale su Arch Linux, lanciate
```bash
$ sudo pacman -S cabal-install ghc happy alex haddock
```
## Gentoo
Su Gentoo, potete installare i singoli componenti della Haskell Platform
attraverso Portage. Se usate `ACCEPT_KEYWORDS=arch` (invece che
`ACCEPT_KEYWORDS=~arch`), Portage installerà versioni più vecchie di Haskell. Tenendone di conto, se usate `ACCEPT_KEYWORDS=arch`, aggiungete le seguenti linee a `/etc/portage/package.keywords`.
dev-haskell/cabal-install
dev-lang/ghc
Una volta fatto quello, lanciate:
```bash
$ emerge -jav dev-lang/ghc dev-haskell/cabal-install
```
Gentoo include una versione "stabile" (leggi: vecchia) di `cabal-install` nell'albero di Portage, quindi vorrete usare `cabal-install` per installare la versione più recente. I backslash sono intenzionali.
```bash
$ \cabal update # I backslash
$ \cabal install cabal-install # sono intentionali
```
Adesso avete installato cabal a livello globale con portage, e localmente nella vostra home directory con `cabal-install`. Il prossimo passo è assicurarsi che quando lanciate `cabal` in un terminale, la vostra shell lanci la versione più recente che è nella vostra home directory. Aggiugete le linee seguenti nel file di configurazione della vostra shell:
```bash
PATH=$PATH:$HOME/.cabal/bin
alias cabal="$HOME/.cabal/bin/cabal"
```
Se non sapete quale shell avete, è molto probabile che la vostra shell sia Bash. Se usate Bash, il file che dovete editare è `~/.bashrc`. se usate Z-shell, il file è `~/.zshrc`. Potete lanciare il seguete comando per sapere qual'è la vostra shell.
```bash
echo $SHELL | xargs basename
```
Io uso zsh, quindi il comando restituisce `zsh` quando lo lancio.
Una volta fatto tutto questo, dovrete installare i tool addizionali `alex` e `happy`.
```bash
$ cabal install alex happy
```
Congratulazioni! Adesso avete una installazione di Haskell funzionante!
## Mac OS X
### 10.9
Installate [GHC per Mac OS X](http://ghcformacosx.github.io/), che include GHC e Cabal. La guida vi darà istruzioni su come installare GHC e Cabal nel vostro path una volta che avete copiato la .app da qualche parte sul disco fisso.
### 10.6-10.8
Eseguite l'installazione dei binari come scritto qui sotto usando [questo tarball](https://www.haskell.org/platform/download/2014.2.0.0/ghc-7.8.3-x86_64-apple-darwin-r3.tar.bz2).
## Windows
- L' [installer minimo per windows di GHC](http://neilmitchell.blogspot.com/2014/12/beta-testing-windows-minimal-ghc.html)
è in grado di compilare `network` e altro. È tecnicamente in beta ma dovrebbe funzionare per gli scopi di chiunque legga questa guida.
Non dimenticatevi di lanciare l'installer come amministratore, dato che è richiesto l'accesso alla directory di sistema 'Programmi'.
## Altri utenti Linux
Scaricate l'ultima distribuzione binaria di cabal e ghc:
- [GHC](http://www.haskell.org/ghc/).
- [Cabal](https://www.haskell.org/cabal/download.html).
# Corsi primari
## Il corso cis194 di Yorgey
> *Seguite questo per primo*, è la strada che raccomando per il primo approccio ad
> Haskell.
Disponibile [online](http://www.seas.upenn.edu/~cis194/spring13/lectures.html).
Il corso di [Brent Yorgey](https://byorgey.wordpress.com) è il migliore che ho trovato finora. Questo corso ha valore non solo perché vi rende in grado di scrivere codice Haskell basilare ma anche perché vi aiuterà a comprendere i parser combinators.
L'unica ragione per cui non dovreste cominciare con cis194 è se non siete programmatori o se non avete molta esperienza. In questo caso, suggerisco di iniziare con il
[libro di Thompson](http://www.haskellcraft.com/craft3e/Home.html) e poi passate a cis194.
---
## Il corso NICTA
> Questo è il corso che raccomando dopo cis194 di Yorgey
Disponibile su github [qui](https://github.com/NICTA/course).
Questo vi darà esperienza nell'implementare direttamente le astrazioni introdotte in cis194. Questi esercizi sono *fondamentali* per sviluppare confidenza con gli usi comuni di Functor/Applicative/Monad/etc. in Haskell. La raccomandazione principale di questa guida è seguire cis194 e poi NICTA: questo è il percorso che seguo per insegnare Haskell a tutti.
---
## Corso Supplementare cs240h
> Fornisce più materiale sugli argomenti intermedi
Disponibile [online](http://www.scs.stanford.edu/14sp-cs240h/).
Questo è il corso online di [Bryan O'Sullivan](https://github.com/bos) tratto dal corso che insegna a Stanford. Se non sapete chi è, date un'occhiata alla metà delle librerie che qualsiasi progetto Haskell richiede e ci troverete il suo nome. Sa avete già seguito il corso di Yorgey sono particolarmente rilevanti i moduli sui phantom types, il flusso di controllo delle informazioni, le estensioni del linguaggio, le concorrenza, le librerie pipes e lenses.
---
## Materiale di riferimento per i tre corsi
[Learn You a Haskell for Great Good (LYAH)](http://learnyouahaskell.com) e
[Real World Haskell](http://book.realworldhaskell.org) (Grazie bos!) sono disponibili online.
Raccomando RWH come referenza (è un libro spesso). I capitoli sul parsing e sulle monadi
sono ottimi per arrivare a capire l'utilità delle monadi stesse. Alcuni hanno detto che è piaciuto molto. Probabilmente è un buon follow-up per imparare gli idiomi in modo pratico, una volta che avete imparato le cose essenziali di Haskell?
### Cosa fa quel syntactic sugar `<-` / `do` / sulle list comprehension?
Eccellente [articolo](http://www.haskellforall.com/2014/10/how-to-desugar-haskell-code.html).
### Per capire list e fold
- [Explain List Folds to Yourself](http://vimeo.com/64673035)
### Per imparare alcune Typeclass di uso comune
Utile per capire `Functor`, `Applicative`, `Monad`, `Monoid` e altre Typeclass di uso comune, ma anche informazioni specifiche di Hask e di Teoria delle Categorie:
- La [Typeclassopedia](http://www.haskell.org/haskellwiki/Typeclassopedia)
### Capire i messaggi di errore più comuni di Haskell
- [Capire i messaggi di errore più comuni](http://ics.p.lodz.pl/~stolarek/_media/pl:research:stolarek_understanding_basic_haskell_error_messages.pdf)
---
# Laziness, strictness, guarded recursion
- Il [libro](http://chimera.labs.oreilly.com/books/1230000000929/ch02.html) di Marlow
sul parallelismo e la concorrenza ha una delle migliori introduzioni alla laziness e alla normal form che abbia trovato. Avrete bisogno di materiale in più se non acquisite i concetti subito.
- [More points for lazy evaluation](http://augustss.blogspot.hu/2011/05/more-points-for-lazy-evaluation-in.html)
- [Oh my laziness!](http://alpmestan.com/posts/2013-10-02-oh-my-laziness.html)
- Domanda su Stack Overflow '[Does haskell have laziness?](http://stackoverflow.com/questions/13042353/does-haskell-have-tail-recursive-optimization)'
- La presentazione di [Johan Tibell](https://github.com/tibbe) su
[reasoning about laziness](http://www.slideshare.net/tibbe/reasoning-about-laziness).
## Breve dimostrazione
```haskell
let a = 1 : a -- guarded recursion, (:) è lazy su di esso si può usare pattern matching.
let (v : _) = a
> v
1
> head a -- head a == v
1
let a = 1 * a -- non guarded, (*) è strict
> a
*** Exception: <<loop>>
```
# IO
- [Evaluation order and State tokens](https://www.fpcomplete.com/user/snoyberg/general-haskell/advanced/evaluation-order-and-state-tokens)
- [Unraveling the mystery of the IO monad](http://blog.ezyang.com/2011/05/unraveling-the-mystery-of-the-io-monad/).
- [First class "statements"](http://blog.jle.im/entry/first-class-statements).
- [Haddocks for System.IO.Unsafe.unsafePerformIO](http://hackage.haskell.org/package/base-4.7.0.1/docs/System-IO-Unsafe.html#v:unsafePerformIO)
Leggete la documentazione e le note sulla implementazione di unsafeDupablePerformIO
Commento da un thread di Reddit, di `glaebhoerl`
> Nota interessante: GHC deve nascondere la rappresentazione dello state token
> dietro un tipo IO astratto perché lo state token deve sempre essere usato linearmente (non
> duplicato o droppato), ma il type system non può garantire che questo accada. Clean, un altro
> linguaggio lazy come Haskell, ha 'uniqueness types' (sono come i linear types
> e possibilmente diversi per aspetti di cui non sono a conoscenza), e espongono
> World-passing direttamente e forniscono una monade IO (non astratta) solo per
> convenienza.
# Monadi and monad transformers
> Non cominciate a imparali finché non capite typeclass, Monoid, Functor e
> Applicative!
Implementate per conto vostro le monadi della libreria standard (List, Maybe, Cont, Error, Reader,
Writer, State) per capirle meglio. Poi potreste provare a scrivere un interprete monadico per piccole espressioni facendo riferimento all'articolo
[Monad Transformers Step by Step](http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf) (menzionata in 'monad transformers' qui sotto).
Scrivere diversi interpreti cambiando solo la monade per cambiare la semantica può aiutarvi a capire in che cosa consiste.
- [Questa presentazione](https://vimeo.com/73648150) di Tony dà un eccellente motivazione per imparare i monad
transformers, [le slide](https://dl.dropboxusercontent.com/u/7810909/talks/monad-transformers/cbaa991e0eb49224eb286c1e418e2b9828e1fb21/monad-transformers.pdf).
Poi reimplementate `Control.Monad`. Funzioni come `mapM` o `sequence` sono buone opportunità per fare esercizio e scrivere codice monadico generico.
Il corso NICTA può essere usato come guida a questo scopo, che include anche lo scrivere la vostra typeclass Applicative.
Referenza:
- Commenti su Reddit di htmltyp and Crandom [qui](http://www.reddit.com/r/haskell/comments/29eke6/basic_program_ideas_for_learning_about_monads/cik5aj6).
- Commenti su Reddit di jozefg [qui](http://www.reddit.com/r/haskell/comments/29eke6/basic_program_ideas_for_learning_about_monads/cik5trg).
## Monad transformers
- [A gentle introduction to Monad Transformers](https://github.com/kqr/gists/blob/master/articles/gentle-introduction-monad-transformers.md).
- [Monad transformers step-by-step](http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf) (attenzione il codice riportato è datato).
# Testare, test, specifiche, testing generativo e di proprietà
- Questo [tutorial](https://github.com/kazu-yamamoto/unit-test-example/blob/master/markdown/en/tutorial.md) di Kazu Yamamoto è fantastico.
- [Simple-Conduit](https://github.com/jwiegley/simple-conduit): Un'ottima libreria per imparare in modo semplice come funziona lo streaming IO in generale; la conoscenza è trasferibile a librerie più complesse come Pipes e Conduit
# Parsing in Haskell
- [Tutorial](https://github.com/JakeWheat/intro_to_parsing) sui Parser combinator
per Haskell, usando Parsec
- [Writing your own micro-Parsec](http://olenhad.me/articles/monadic-parsers/)
## Parsare e generare JSON
Aeson è la soluzione di parsing [JSON](https://json.org) standard in
haskell. Disponibile su [hackage](https://hackage.haskell.org/package/aeson) e
[github](https://github.com/bos/aeson).
- [Parsing JSON using Aeson](http://blog.raynes.me/blog/2012/11/27/easy-json-parsing-in-haskell-with-aeson/)
- [Aeson and user created types](http://bitemyapp.com/posts/2014-04-11-aeson-and-user-created-types.html)
- [Parsing non-deterministic data with aeson and sum types](http://bitemyapp.com/posts/2014-04-17-parsing-nondeterministic-data-with-aeson-and-sum-types.html)
- [Tutorial di Aeson](https://www.fpcomplete.com/school/starting-with-haskell/libraries-and-frameworks/text-manipulation/json)
# Algoritmi per grafi e strutture dati
- Il [pacchetto fgl](https://hackage.haskell.org/package/fgl) gli [algoritmi](http://hackage.haskell.org/package/fgl-5.4.2.2/docs/Data-Graph-Inductive-Query-SP.html) puramente funzionali per trovare la strada più breve.
- [Inductive graphs and Functional Graph Algorithms](http://web.engr.oregonstate.edu/~erwig/papers/abstracts.html#JFP01).
- [FGL/Haskell - A Functional Graph Library](http://web.engr.oregonstate.edu/~erwig/fgl/haskell/old/fgl0103.pdf).
- [Data.Graph source from Containers package](http://hackage.haskell.org/package/containers-0.5.5.1/docs/Data-Graph.html).
- Il [pacchetto graphs](https://hackage.haskell.org/package/graphs).
- [Domande su SO riguardo a PHOAS](http://stackoverflow.com/questions/24369954/separate-positive-and-negative-occurrences-of-phoas-variables-in-presence-of-rec)
- [PHOAS for free](https://www.fpcomplete.com/user/edwardk/phoas).
- [Tying the Knot](http://www.haskell.org/haskellwiki/Tying_the_Knot).
- [Hackage: dag](https://hackage.haskell.org/package/dag).
# Ambienti di sviluppo
## Emacs
- [Il tutorial di Alejandro Serras](https://github.com/serras/emacs-haskell-tutorial/blob/master/tutorial.md)
- [I miei dotfiles](https://github.com/bitemyapp/dotfiles/)
- [Il config emacs di Chris Done](https://github.com/chrisdone/chrisdone-emacs)
## Vim
- [Pagina di Vim su haskellwiki](http://www.haskell.org/haskellwiki/Vim)
- [Haskell-vim-now](https://github.com/begriffs/haskell-vim-now)
- [Un workflow vim+haskell](http://www.stephendiehl.com/posts/vim_haskell.html)
- [GHC-Mod](https://github.com/kazu-yamamoto/ghc-mod)
- [GHC-Mod vim plugin](https://github.com/eagletmt/ghcmod-vim)
- [Hindent](https://github.com/chrisdone/hindent)
## Sublime Text
- [SublimeHaskell](https://github.com/SublimeHaskell/SublimeHaskell)
# FAQ e lavorare con Cabal
## Una FAQ fantastica
Oltre ad essere una guida eccezionale per vare cose, come i GADT, questa guida copre anche alcune utili basi di Cabal
- [Quello che vorrei aver saputo mentre imparavo Haskell](http://dev.stephendiehl.com/hask/)
anche su github [qui](https://github.com/sdiehl/wiwinwlh).
## Linee guida di Cabal
Prima dell'introduzione dei sandbox, gli utenti Haskell incappavano nel problema definito Cabal Hell (Inferno di Cabal). Se non utilizzate una sandbox, cabal installerà il pacchetto nel vostro user package-db. Questa *non* è in genere una buona idea, fatta l'eccezione per alcuni pacchetti di base come
Cabal, alex e happy. Nient'altro dovrebbe essere installato nel package-db dell'utente né tanto meno a livello globale, a meno che non sappiate cosa state facendo.
Alcune raccomandazioni per non cadere nel Cabal Hell sono disponibili
[qui](http://softwaresimply.blogspot.com/2014/07/haskell-best-practices-for-avoiding.html).
Per provare un pacchetto o cominciare un progetto, iniziate lanciando
`cabal sandbox init` in una nuova directory.
In poche parole:
- Quando installate nuovi pacchetti, create nuovi progetti o pre-esistenti, o cominciate esperimenti usate sempre i sandbox.
- Usate `cabal repl` invece per iniziare una istanza di ghci come project-scoped
Questo approccio basato sui sandbox dovrebbe scamparvi dai problemi relativi alle dipendenze dei paccheti, ma è incompatibile con il modo in cui la Haskell Platform fornisce i pacchetti binari. Se state imparando Haskell e non capite come funzionano ghc-pkg e Cabal, *evitate la haskell platform*, ed usate invece le istruzioni all'inizio della guida.
## Stackage
Tutti gli utenti (di solito utenti di Yesod) che hanno problemi di build potrebbero provare ad utilizzare Stackage.
- Un buon riassunto di Stackage è
[qui](https://www.fpcomplete.com/blog/2014/05/stackage-server).
Secondo l'opinione dell'autore, Stackage è in genere più utile di `cabal freeze`.
# Hoogle e Haddock
## Ricerca di codice mediante type signature
Il [motore di ricerca Hoogle](http://www.haskell.org/hoogle/) può cercare per tipo.
Per esempio, guardate i risultati della ricerca per `(a -> b) -> [a] -> [b]`
[qui](http://www.haskell.org/hoogle/?hoogle=%28a+-%3E+b%29+-%3E+%5ba%5d+-%3E+%5bb%5d).
Lo trovate anche su fpcomplete [qui](https://www.fpcomplete.com/hoogle).
Anche [Hayoo](http://holumbus.fh-wedel.de/hayoo/hayoo.html) (che cerca su tutto Hackage per default).
## Setup della tua istanza locale di Hoogle
Guardate [qui](https://gist.github.com/bitemyapp/3e6a015760775e0679bf).
## Haddock
1. [Aggiusta la tua documentazione hackage](http://fuuzetsu.co.uk/blog/posts/2014-01-06-Fix-your-Hackage-documentation.html)
2. [Documentazione Hackage v2](http://fuuzetsu.co.uk/blog/posts/2014-01-06-Hackage-documentation-v2.html)
Fate attenzione, questi post sono *lievemente obsoleti*: per esempio, adesso Hackage vanta nuovi modi di mostrare informazioni, documentazione e stato del build.
## Quello che davvero avete bisogno di sapere
Per far includere ad haddocks la documentazione per i pacchetti correlati, dovete settare `documentation: True` nel vostro `~/.cabal/config`. Se lasciato sul valore di default (`False`) o settato a `False`, prima di rigenerare la documentazione dovrete rimuovere tutti i vostri pacchetti e reinstallarli.
L'altra cosa da tenere a mente è che a causa del modo in cui il parametro `$pkg` viene interpretato *da* cabal, non da voi, i parametri `html-location` e `content-location` *devono essere fra apici* e inseriti in una shell o in uno shell script. Non funzioneranno in un Makefile, perché crederanno di essere variabili di Make!
```bash
#! /usr/bin/env sh
# potete scrivero su una linea sola non mettendo backslash
cabal haddock --hoogle --hyperlink-source \
--html-location='http://hackage.haskell.org/package/$pkg/docs' \
--contents-location='http://hackage.haskell.org/package/$pkg'
```
# TravisCI
Se siete fan di [TravisCI](https://travis-ci.org) come lo sono io, allora vi consiglio
*caldamente* di dare un'occhiata a
[multi-ghc-travis](https://github.com/hvr/multi-ghc-travis) come base per il `travis.yml` dei vostri progetti Haskell.
# Frontend/JavaScript
Abbiamo l'imbarazzo della scelta! Ci sono tre scelte principali che raccomanderei:
* [Haste](http://haste-lang.org/) un compilatore da Haskell a JavaScript
- Il [compilatore](https://github.com/valderman/haste-compiler) su github.
- Una [demo](http://www.airpair.com/haskell/posts/haskell-tutorial-introduction-to-web-apps)
eccellente di Haste con un progetto di esempio.
* [GHCJS](https://github.com/ghcjs/ghcjs)
- [Introduzione a GHCJS](http://weblog.luite.com/wordpress/?p=14)
- [Functional Reactive Web Interfaces with GHCJS and Sodium](http://weblog.luite.com/wordpress/?p=127)
- [Writing Atom plugins in Haskell using ghcjs ](http://edsko.net/2015/02/14/atom-haskell/)
* [PureScript](http://www.purescript.org/)
- Non è strettamente Haskell come Haste e GHCJS, ma è una scelta popolare fra i programmatori Haskell
- Scritto in ed ispirato ad Haskell
- Provate purescript nel vostro browser [here](http://try.purescript.org/)
- Ottima guida per [cominciare a usarlo](http://www.christopherbiscardi.com/2014/06/22/getting-started-with-purescript/)
## Quale linguaggio scegliere per il frontend?
GHCJS e Haste sono entrambi interamente compatibili con Haskell. GHCJS è compatibile con un numero maggiore di pacchetti Haskell rispetto a Haste, ma questo non è rilevante per molti progetti frontend. Al contrario, PureScript non è Haskell, per tanto non potrete condividere il codice fra frontend e backend.
GHCJS ha un runtime più grande, a 100kb (luite ci sta lavorando). Haste e PureScript sono competitivi.
PureScript ha la migliore integrazione con i tool di JS (usa gulp/grunt/bower), mentre GHCJS
e Haste si integrano meglio con i tool di Haskell (Cabal).
Tutti e tre sono un'ottima scelta e possono funzionare per la maggioranza dei progetti frontend.
# Per una comprensione più profonda della laziness, NF, WHNF
- [Notes on lambda calculus](https://vec.io/posts/notes-on-lambda-calculus).
## Articoli di ricerca sul lazy lambda calculi
- [A call by need lambda calculus](http://homepages.inf.ed.ac.uk/wadler/topics/call-by-need.html#need-journal).
- [Demonstrating Lambda Calculus Reduction](http://www.itu.dk/~sestoft/papers/sestoft-lamreduce.pdf)
- [The lazy lambda calculus](http://www.cs.ox.ac.uk/files/293/lazy.pdf).
- [Lazy evaluation of Haskell](http://www.vex.net/~trebla/haskell/lazy.xhtlm)
# Parallelismo/Concorrenza
- Il libro [Parallel and Concurrent Programming in Haskell](http://chimera.labs.oreilly.com/books/1230000000929) di Simon Marlow è probabilmente il migliore che abbia mai letto sull'argomento.
- Un [walk-through](http://kukuruku.co/hub/haskell/haskell-testing-a-multithread-application) completo su testing e incremental development di un applicazione multi-threaded in Haskell.
- [Functional Reactive Programming](http://www.haskell.org/haskellwiki/Functional_Reactive_Programming)
# Lenses e Prisms
Una volta che vi trovate a vostro agio con Haskell, è molto utile imparare Lens e
Prism, anche se solo come "utente". Non avete bisogno di capire le categorie sottostanti
perchè vi siano utili.
La difficoltà di usare la libreria Lens è generalmente sovrastimata. Chiunque sia a suo agio con Functor/Foldable/Traversable (o anche solo il primo) può usare lens e prism per rendersi la vita più facile.
Se vi è capitato di fare qualcosa come: `(fmap . fmap)` stavate usando mentalmente le 'lenti'.
Raccomando questi due tutorial/introduzioni:
- [A little lens starter tutorial](https://www.fpcomplete.com/school/to-infinity-and-beyond/pick-of-the-week/a-little-lens-starter-tutorial)
- [Lens: Lenses, Folds and Traversals](https://github.com/ekmett/lens#lens-lenses-folds-and-traversals)
Leggete questo per maggiori informazioni: [pacchetto Lens su hackage](http://hackage.haskell.org/package/lens).
# Schemi di ricorsione
Alcune delle pazze parole di cui avete sentito parlare che finiscono con \*-morfismo riguardano la ricorsione. NB - prima di iniziare a studiare il materiale che segue dovreste sapere come implementare foldr per le liste e almeno un'altra struttura di dati, tipo un albero. (i fold sono catamorfismi) Sapere come implementare un unfold (anamorfismo) per le stesse strutture dati è complementare.
Questo materiale si compenetra con traversable e foldable.
- [An introduction to recursion schemes](http://patrickthomson.ghost.io/an-introduction-to-recursion-schemes/)
- [Don't fear the cat](http://fho.f12n.de/posts/2014-05-07-dont-fear-the-cat.html) -
Buona dimostrazione su come l'ilomorfismo sia la composizione di cata e ana.
- [Recursion Schemes](http://comonad.com/reader/2009/recursion-schemes/) - Questa guida è ottima.
- [Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire](http://eprints.eemcs.utwente.nl/7281/01/db-utwente-40501F46.pdf)
- [Catamorphisms](https://www.fpcomplete.com/user/edwardk/recursion-schemes/catamorphisms)
# GHC Core e ottimizzazione della performance
- [Write Haskell as Fast as C](write_haskell_as_fast_as_c.md)
- [GHC Wiki: CoreSyn Type](https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/CoreSynType).
- [Hackage: GHC Core](https://hackage.haskell.org/package/ghc-core).
- [SO Question: Reading GHC Core](http://stackoverflow.com/questions/6121146/reading-ghc-core).
- [Haskell as fast as 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, Chapter 25: Profiling and Optimizations](http://book.realworldhaskell.org/read/profiling-and-optimization.html).
# Tipi e Teoria delle Categorie
> *Non* è necessaria per scrivere Haskell, solo per quelli interessati!
Se volete imparare di più su tipi e teoria delle categorie:
- [La guida di Catster](http://byorgey.wordpress.com/2014/01/14/catsters-guide/) e [La seconda guida Catster](http://byorgey.wordpress.com/catsters-guide-2/)
- Il [wikibook haskell](http://en.wikibooks.org/wiki/Haskell/Category_theory) ha dei bei diagrammi
- [Teoria delle categorie](http://www.haskell.org/haskellwiki/Category_theory) su haskellwiki, ha anche buoni link ad altre risorse
- [Categories from scratch](http://science.raphael.poss.name/categories-from-scratch.html), include alcuni esempi pratici.
- La lista [Great Works in PL](http://www.cis.upenn.edu/~bcpierce/courses/670Fall04/GreatWorksInPL.shtml) di Pierce.
## Libri
- [Quora Question: What is the best textbook for category theory?](http://www.quora.com/Category-Theory/What-is-the-best-textbook-for-Category-theory?share=1) le raccomandazioni di Kmett
- [Awodey](http://ukcatalogue.oup.com/product/9780199237180.do) e
[MacLane](http://www.amazon.com/Categories-Working-Mathematician-Graduate-Mathematics/dp/0387984038). I libri di testo standard sulla teoria delle categorie
- [Harper's Practical Foundations for Programming Languages](http://www.cs.cmu.edu/~rwh/plbook/book.pdf) è la miglior introduzione alla teoria delle categorie focalizzata sui linguaggi di programmazione.
- [Type theory and Functional Programming](http://www.cs.kent.ac.uk/people/staff/sjt/TTFP/).
## Gli ottimi articoli di Stephen su "Come capire le monadi"
- [Adjunctions](http://www.stephendiehl.com/posts/adjunctions.html).
- [Monads](http://www.stephendiehl.com/posts/monads.html).
# Altri argomenti divertenti
## Parametricità, ad-hoc vs. polimorfismo parametrico e teoremi liberi
- [Parametricity](tony_parametricity.pdf).
- [Sorgenti TeX](https://github.com/tonymorris/parametricity/) per la presentazione di cui sopra.
- [Making ad-hoc polymorphism less ad-hoc](http://swizec.com/blog/week-20-making-ad-hoc-polymorphism-less-ad-hoc/swizec/6564).
- [Theorems for Free!](http://ttic.uchicago.edu/~dreyer/course/papers/wadler.pdf).
## Inizial e Final, DSL, Finally Tagless
- [Final Encodings, Part 1: A Quick Demonstration](http://creativelad.wordpress.com/2013/11/28/final-encodings-part-1-a-quick-demonstration/).
- [Transforming Polymorphic Values](http://martijn.van.steenbergen.nl/journal/2009/10/18/transforming-polymorphic-values/).
- [GADTs in Haskell 98](http://martijn.van.steenbergen.nl/journal/2009/11/12/gadts-in-haskell-98/).
- [Typed Tagless-Final Linear Lambda Calculus](https://www.fpcomplete.com/user/mutjida/typed-tagless-final-linear-lambda-calculus).
- [Typed tagless-final interpretations: Lecture notes](http://okmij.org/ftp/tagless-final/course/course.html).
- [Typed Tagless Final Interpreters](http://okmij.org/ftp/tagless-final/course/lecture.pdf).
- [The dog that didn't bark](http://existentialtype.wordpress.com/2011/03/21/the-dog-that-didnt-bark/) meno rilevante nello specifico ma comunque interessante.
## Comonadi
- [Comonads in Haskell](https://speakerdeck.com/dmoverton/comonads-in-haskell).
- [SO question: Can a Monad be a Comonad](http://stackoverflow.com/questions/16551734/can-a-monad-be-a-comonad).
## Yoneda / CoYoneda
- [SO question: Step-by-step explanation of coyoneda](http://stackoverflow.com/questions/24000465/step-by-step-deep-explain-the-power-of-coyoneda-preferably-in-scala-throu).
- Free monads for Less, una sequenza di tre articoli di Edward Kmett
* [Part 1: Codensity](http://comonad.com/reader/2011/free-monads-for-less/).
* [Part 2: Yoneda](http://comonad.com/reader/2011/free-monads-for-less-2/).
* [Part 3: Yielding IO](http://comonad.com/reader/2011/free-monads-for-less-3/).
## Propositions vs. Judgments (computazione)
- [StackExchange question: What is the difference between propositions and judgements](http://cstheory.stackexchange.com/questions/9826/what-is-the-difference-between-propositions-and-judgments).
- [Lecture notes from a short, three lecture course](http://www.ae-info.org/attach/User/Martin-L%C3%B6f_Per/OtherInformation/article.pdf)
# Tipi dipendenti
- [Grokking sum types, value constructors, and type constructors](http://bitemyapp.com/posts/2014-04-05-grokking-sums-and-constructors.html) strizzate gli occhi.
- [Lightweight Dependent-type Programming](http://okmij.org/ftp/Computation/lightweight-dependent-typing.html).
- [Idris programming language](http://www.idris-lang.org/).
# Linkare binari staticamente
- [Static linking](https://wiki.haskell.org/Web/Literature/Static_linking)
- [Static linking with GHC on Arch Linux](http://www.edofic.com/posts/2014-05-03-ghc-arch-static.html)
- [Statically linking Linux binaries for ARM & MIPS](http://stackoverflow.com/questions/14270177/ghc-statically-linking-linux-binaries-for-arm-mips-processors)
- [Statically link GMP using GHC and LLVM](http://stackoverflow.com/questions/10539857/statically-link-gmp-to-an-haskell-application-using-ghc-llvm)
# Lista estesa di materiali da leggere
> Alcuni sono già inclusi qui
- [Essential Haskell Reading List](http://www.stephendiehl.com/posts/essential_haskell.html)
## Dialoghi
> Disponibile in questo repository [qui](dialogues.md).
Questi sono in realtà importanti e utili. Leggeteli per approfondimenti su una varietà di argomenti.

812
guide-pt.md
View File

@ -0,0 +1,812 @@
# O Guia
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 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).
Obrigado por disponibilizar isso, Recurse Center.
# O que é Haskell, GHC, e Cabal?
Haskell é uma linguagem de programação como é definido nos relatórios, o
mais recente sendo o de 2010. O relatório está disponível como
[onlinereport](http://www.haskell.org/onlinereport/haskell2010/).
## GHC
[GHC](http://www.haskell.org/ghc/) é o meio mais popular de se trabalhar na
linguagem Haskell. Ele inclui um compilador, REPL (interpretador), gerenciamento
de pacotes, e outras coisas mais.
## Cabal
[Cabal](https://www.haskell.org/cabal/download.html) realiza gerenciamento de projetos e
resolução de dependências. É como você instalará projetos, tipicamente na própria *sandbox* deles.
Cabal é equivalente ao Bundler do Ruby, pip do Python, NPM do Node.js, Maven,
etc. O GHC é responsável pelos pacotes propriamente ditos, o Cabal escolhe
quais versões serão instaladas.
# Configurações iniciais
## Ubuntu
[Este PPA](http://launchpad.net/~hvr/+archive/ghc) é excelente e é o que eu
uso em todas as máquinas Linux de desenvolvimento e produção.
Especificamente:
```bash
$ sudo apt-get update
$ sudo apt-get install python-software-properties # v12.04 e abaixo
$ sudo apt-get install software-properties-common # v12.10 e acima
$ sudo add-apt-repository -y ppa:hvr/ghc
$ sudo apt-get update
$ sudo apt-get install cabal-install-1.20 ghc-7.8.4 happy-1.19.4 alex-3.1.3
```
Então adicione o seguinte ao seu `$PATH` (bash\_profile, zshrc, bashrc, etc):
```
~/.cabal/bin:/opt/cabal/1.20/bin:/opt/ghc/7.8.4/bin:/opt/happy/1.19.4/bin:/opt/alex/3.1.3/bin
```
*Opcional:* Você também pode adicionar `.cabal-sandbox/bin` ao seu *path*.
Código que você está desenvolvendo ativamente estará disponível a partir
da sua linha de comando. Isso funciona apenas quando o diretório de trabalho
atual é uma *sandbox* do cabal.
## Debian
### Usando Ubuntu PPA
Se você não está usando o *stable*, pode seguir os mesmos passos do Ubuntu, mas
precisará executar um comando adicional. Imediatamente após o
`sudo add-apt-repository -y ppa:hvr/ghc`, execute:
```bash
$ sudo sed -i s/jessie/trusty/g /etc/apt/sources.list.d/hvr-ghc-jessie.list
```
Para outras versões do Debian, apenas substitua todas as ocorrências de `jessie`
com o nome da sua versão no comando acima.
Se, por alguma razão, o arquivo `/etc/apt/sources.list.d/hvr-ghc-jessie-list` não
existir, então `/etc/apt/sources.list` deve conter uma linha assim:
deb http://ppa.launchpad.net/hvr/ghc/ubuntu jessie main
Substitua `jessie` por `trusty` nesta linha.
### Compilação manual
Você pode seguir [este](http://www.davesquared.net/2014/05/platformless-haskell.html)
guia escrito para Mac OS X:
Notas:
- Configure o seu prefixo adequadamente quando configurar o ghc.
- Em vez de pegar o binário do `cabal-install`, pegue o código fonte e execute
o *script* `bootstrap.sh`.
## Fedora 21
Para instalar o Haskell 7.8.4 a partir do repositório não-oficial (versões 22+ do Fedora vão incluí-lo
no oficial):
```bash
$ sudo yum-config-manager --add-repo \
> https://copr.fedoraproject.org/coprs/petersen/ghc-7.8.4/repo/fedora-21/petersen-ghc-7.8.4-fedora-21.repo
$ sudo yum install ghc cabal-install
```
Como dito na [página do copr
petersen/ghc-7.8.4](https://copr.fedoraproject.org/coprs/petersen/ghc-7.8.4/)
este ghc não pode ser instalado em paralelo com o ghc do Fedora/EPEL.
## Arch Linux
Para instalar o Haskell dos repositórios oficiais no Arch Linux, execute
```bash
$ sudo pacman -S cabal-install ghc happy alex haddock
```
## Gentoo
No Gentoo, você pode instalar os componentes individuais da Plataforma Haskell
através do Portage. Se você usar `ACCEPT_KEYWORDS=arch` (em vez de `ACCEPT_KEYWORDS=~arch`),
o Portage vai instalar versões antigas dos vários componentes do Haskell.
Com isso em mente, se você usar `ACCEPT_KEYWORDS=arch`, adicione o seguinte ao
`/etc/portage/package.keywords`:
dev-haskell/cabal-install
dev-lang/ghc
Uma vez que isso foi feito,
```bash
$ emerge -jav dev-lang/ghc dev-haskell/cabal-install
```
O Gentoo mantém uma versão "estável" (leia-se: antiga) do `cabal-install` na
árvore do Portage, então você vai querer usar o `cabal-install` para instalar
a versão mais recente. Note que as contrabarras são intencionais.
```bash
$ \cabal update # As contrabarras
$ \cabal install cabal-install # são intencionais
```
Agora você instalou o cabal num escopo global com o portage, e localmente no
seu diretório *home* com o `cabal-install`. O próximo passo é garantir que
quando você executar o comando `cabal` num terminal, seu *shell* vai executar a
versão recente que está no seu diretório *home*. Para isso, as seguintes linhas
devem ser adicionadas ao arquivo de configuração do seu *shell*:
```bash
PATH=$PATH:$HOME/.cabal/bin
alias cabal="$HOME/.cabal/bin/cabal"
```
Se não sabe qual *shell* é o seu, provavelmente ele é o Bash. Se você usa o
Bash, o arquivo a ser editado é o `~/.bashrc`. Se você usa o Z-shell(zsh), o
arquivo é o `~/.zshrc`. Você pode executar o seguinte comando para descobrir
qual é o seu *shell*.
```bash
echo $SHELL | xargs basename
```
Eu uso o zsh, então esse comando produz `zsh` como saída.
Uma vez que você fez tudo isso, você vai querer instalar as ferramentas adicionais
`alex` e `happy`.
```bash
$ cabal install alex happy
```
Parabéns! Agora você tem uma instalação funcional do Haskell!
## Mac OS X
### 10.9
Instale o app [GHC for Mac OS X](http://ghcformacosx.github.io/), que inclui o
GHC e o Cabal. Ele traz instruções sobre como adicionar o GHC e o Cabal ao seu
*path* depois de ter arrastado o `.app` para algum lugar.
### 10.6-10.8
Faça a instalação da distribuição binária descrita
[neste arquivo](https://www.haskell.org/platform/download/2014.2.0.0/ghc-7.8.3-x86_64-apple-darwin-r3.tar.bz2).
## Windows
- O [instalador mínimo do GHC para Windows] (http://neilmitchell.blogspot.com/2014/12/beta-testing-windows-minimal-ghc.html)
é capaz de compilar `network` e etc. Tecnicamente está em beta, mas deve
funcionar para os propósitos de qualquer um que está lendo este guia.
Não esqueça de rodar o instalador como administrador, já que ele vai querer
instalar no seu Arquivos de Programas.
## Usuários de outros Linux
Baixe as últimas distribuições binárias para o cabal e ghc:
- [GHC](http://www.haskell.org/ghc/).
- [Cabal](https://www.haskell.org/cabal/download.html).
# Cursos Iniciais
## Curso cis194 do Yorgey
> *Faça este primeiro*, esta é a minha recomendação de como ser introduzido
> ao Haskell.
Disponível [online](http://www.seas.upenn.edu/~cis194/spring13/lectures.html).
O curso de [Brent Yorgey](https://byorgey.wordpress.com) é o melhor que eu
encontrei até agora. Esse curso é importante porque ele não só vai equipá-lo
a escrever Haskell básico mas também vai ajudá-lo a entender *parser combinators*.
A única razão pela qual você não deveria começar com o cis194 é se você não
for um programador ou se for um que é inexperiente. Se esse é o caso, comece
com o [livro do Thompson](http://www.haskellcraft.com/craft3e/Home.html) e depois
o cis194.
---
## Curso NICTA
> Este é o curso que recomendo fazer após o curso cis194 do Yorgey.
Disponível no github [aqui](https://github.com/NICTA/course).
Isso vai reforçar e lhe dar experiência implementado diretamente as abstrações
introduzidas no cis194. Essa prática é *crítica* para alguém se tornar confortável
com o uso diário de *Functors*/*Applicatives*/*Monads*/etc em Haskell. Fazer o cis194
e então o curso do NICTA representa a recomendação fundamental do meu guia,
e é como eu ensino Haskell para todo mundo.
---
## Curso suplementar cs240h
> Fornece mais materiais em tópicos intermediários
Disponível [online](http://www.scs.stanford.edu/14sp-cs240h/).
Essa é a versão online do curso que o [Bryan O'Sullivan](https://github.com/bos)
leciona em Stanford. Se você não sabe quem ele é, dê uma olhada em metade
das bibliotecas que qualquer aplicação em Haskell acaba precisando e o nome
dele estará nela. Se você já fez o curso do Yorgey, são particularmente
interessantes os módulos sobre tipos fantasma (*phantom types*), controle de fluxo
da informação (*information flow control*), extensões de linguagem (*language extensions*),
concorrência, *pipes* e *lenses*.
---
## Material de referência para os três cursos
[Learn You a Haskell for Great Good (LYAH)](http://learnyouahaskell.com) e o
[Real World Haskell](http://book.realworldhaskell.org) (Obrigado, bos!) estão
disponíveis online.
Eu recomendo o RWH como referência (livro grosso). Os capítulos sobre
*parsing* e *monads* são ótimos para entender onde *monads* são úteis. Outras pessoas
já disseram que gostaram muito deles. Talvez seja um bom seguimento para
aplicações práticas depois que você já está acostumado com o essencial de Haskell.
### O que os açúcares sintáticos `<-` / `do` / compreensão de listas fazem exatamente?
Excelente [artigo](http://www.haskellforall.com/2014/10/how-to-desugar-haskell-code.html).
### Para entender listas e *folds*
- [Explique *folds* em Listas para si mesmo](http://vimeo.com/64673035)
### Para aprender *typeclasses* comuns
Útil para entender `Functor`, `Applicative`, `Monad`, `Monoid` e outras *typeclasses*
em geral, mas também conceitos de Teoria das Categorias específicos à Hask.
- A [Typeclassopedia](http://www.haskell.org/haskellwiki/Typeclassopedia)
### Entendendo mensagens de erro básicas do Haskell
- [Entendendo mensagens de erro básicas](http://ics.p.lodz.pl/~stolarek/_media/pl:research:stolarek_understanding_basic_haskell_error_messages.pdf)
### Avaliação preguiçosa, estrita, recursão guardada
- O [livro](http://chimera.labs.oreilly.com/books/1230000000929/ch02.html) de Marlow
paralelismo e concorrência tem uma das melhores introduções sobre avaliação preguiçosa
e forma normal que já encontrei. Use outros materiais também se não fizer sentido imediatamente.
- [Mais pontos para a avaliação preguiçosa](http://augustss.blogspot.hu/2011/05/more-points-for-lazy-evaluation-in.html)
- [Oh minha preguiça!](http://alpmestan.com/posts/2013-10-02-oh-my-laziness.html)
- 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)
- [Tutorial Aeson](https://www.fpcomplete.com/school/starting-with-haskell/libraries-and-frameworks/text-manipulation/json)
# Algoritmos de Grafo e Estrutura de Dados
- 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).
- [Hackage: dag](https://hackage.haskell.org/package/dag).
# Ambiente de Desenvolvimento
## Emacs
- [Tutorial de Alejandro Serras](https://github.com/serras/emacs-haskell-tutorial/blob/master/tutorial.md)
- [Meus *dotfiles*](https://github.com/bitemyapp/dotfiles/)
- [Configuração do emacs do Chris Done](https://github.com/chrisdone/chrisdone-emacs)
## Vim
- [Página do Vim no haskellwiki](http://www.haskell.org/haskellwiki/Vim)
- [Haskell-vim-now](https://github.com/begriffs/haskell-vim-now)
- [Um *workflow* com vim+haskell](http://www.stephendiehl.com/posts/vim_haskell.html)
- [GHC-Mod](https://github.com/kazu-yamamoto/ghc-mod)
- [Plugin do vim para o GHC-Mod](https://github.com/eagletmt/ghcmod-vim)
- [Hindent](https://github.com/chrisdone/hindent)
## Sublime Text
- [SublimeHaskell](https://github.com/SublimeHaskell/SublimeHaskell)
# FAQ e trabalhando com o Cabal
## FAQ fantástico
Além de ser um ótimo guia para todos tipo de coisa como GADTs,
isto também cobre alguns pontos básicos do Cabal.
- [O que eu gostaria de ter sabido quando estava aprendendo Haskell](http://dev.stephendiehl.com/hask/)
também no github [aqui](https://github.com/sdiehl/wiwinwlh).
## Diretrizes do Cabal
O *Cabal Hell* (Inferno do Cabal) era um problema para usuário de Haskell
antes da introdução das *sandboxes*. Instalar fora de uma *sandbox* vai instalar
no package-db de seu usuário. Isso *não* é uma boa ideia, exceto para pacotes
fundamentais como Cabal, alex e happy. Nada além disso deve ser instalado nos
package-dbs do usuário ou global a menos que você saiba o que está fazendo.
Algumas melhores práticas para evitar o *cabal hell* estão disponíveis
[aqui](http://softwaresimply.blogspot.com/2014/07/haskell-best-practices-for-avoiding.html).
Para experimentar um pacote ou iniciar um projeto, comece fazendo
`cabal sandbox init` num novo diretório.
Colocando brevemente:
- Sempre use *sandboxes* para instalar novos pacotes, compilar projetos
novos ou existentes, ou iniciar experimentos.
- Use o `cabal repl` para iniciar uma instância do ghci com escopo limitado ao projeto.
A abordagem baseada em *sandbox* que sugiro deve evitar problemas em dependência
de pactes, mas é incompatível com a maneira que a Plataforma Haskell fornece
pacotes pré-compilados. Se você ainda está aprendendo Haskell e não entende como o
ghc-pkg e o Cabal funcionam, *evite a plataforma* e em vez dela use as instruções para
instalação no começo deste guia.
## Stackage
Para qualquer usuários (principalmente os do Yesod) que tem problemas de compilação,
considere o Stackage.
- Um bom sumário do Stackage [aqui](https://www.fpcomplete.com/blog/2014/05/stackage-server).
Na opinião do autor, o Stackage é geralmente mais útil do que o `cabal freeze`.
# Hoogle e Haddock
## Pesquise código pela *type signature*
O [motor de buscas Hoogle](http://www.haskell.org/hoogle/) pode pesquisar pelos tipos.
Por exemplo, olhe os resultados de busca para `(a -> b) -> [a] -> [b]`
[aqui](http://www.haskell.org/hoogle/?hoogle=%28a+-%3E+b%29+-%3E+%5ba%5d+-%3E+%5bb%5d).
Também hospedado pelo fpcomplete [aqui](https://www.fpcomplete.com/hoogle).
Também o [Hayoo](http://holumbus.fh-wedel.de/hayoo/hayoo.html) (que por padrão tem tudo do
hackage disponível para pesquisa).
## Configurando sua própria instância local do Hoogle
Dê uma olhada [aqui](https://gist.github.com/bitemyapp/3e6a015760775e0679bf).
## Haddock
1. [Conserte sua documentação do hackage](http://fuuzetsu.co.uk/blog/posts/2014-01-06-Fix-your-Hackage-documentation.html)
2. [Documentação v2 do Hackage](http://fuuzetsu.co.uk/blog/posts/2014-01-06-Hackage-documentation-v2.html)
Perceba que essas postagens estão *levemente desatualizadas*: por exemplo, agora o Hackage exibe
informação nova com destaque com informação de documentação e o estado da *build*.
## O que você realmente precisa saber
Para fazer com que o haddocks inclua documentação para pacotes relacionados,
você deve setar `documentation: True` no seu `~/.cabal/config`. Se ele for deixado
no padrão (`False`) ou setado para `False`, você vai precisar deletar todos os seus
pacotes e reinstalar antes de gerar os haddocks.
Outra coisa para se ter em mente é que devido ao modo como o parâmetro `$pkg` é
interpolado *pelo* cabal, não por você, os parâmetros `html-location` e `content-location`
*precisam estar em aspas simples* e configurados num *shell* ou contidos num *shell script*.
Eles não vão funcionar num Makefile, porque ele vai pensar que são variáveis para o Make!
```bash
#! /usr/bin/env sh
# You can write it one one line by skipping the backslashes
cabal haddock --hoogle --hyperlink-source \
--html-location='http://hackage.haskell.org/package/$pkg/docs' \
--contents-location='http://hackage.haskell.org/package/$pkg'
```
# TravisCI
Se você é um grande fã do [TravisCI](https://travis-ci.org) como eu sou,
então recomendo *fortemente* que considere o
[multi-ghc-travis](https://github.com/hvr/multi-ghc-travis) como base para
o `travis.yml` em seus projetos em Haskell.
# *Frontend*/Javascript
Nós temos muita coisa nessa área! Existem três opções principais que eu recomendaria:
* [Haste](http://haste-lang.org/) um compilador de Haskell para Javascript
- O [compilador](https://github.com/valderman/haste-compiler) no github.
- Uma excelente
[demonstração](http://www.airpair.com/haskell/posts/haskell-tutorial-introduction-to-web-apps)
do Haste com um projeto de exemplo
* [GHCJS](https://github.com/ghcjs/ghcjs)
- [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)
- [O cálculo lambda preguiçoso](http://www.cs.ox.ac.uk/files/293/lazy.pdf).
- [Avaliação preguiçosa em Haskell](http://www.vex.net/~trebla/haskell/lazy.xhtml)
# Paralelismo/Concorrência
- [Programação Paralela e Concorrente em Haskell](http://chimera.labs.oreilly.com/books/1230000000929).
Este livro de Simon Marlow é provavelmente o melhor que já li no tema de
Paralelismo e Concorrência.
- Um bom [passeio](http://kukuruku.co/hub/haskell/haskell-testing-a-multithread-application)
através do processo de teste e desenvolvimento incremental de uma aplicação
multi-*thread* em Haskell.
- [Programação Funcional Reativa](http://www.haskell.org/haskellwiki/Functional_Reactive_Programming)
# *Lenses* e *Prisms*
Depois de estar confortável em Haskell, considere seriamente aprender *Lenses* e *Prisms*,
mesmo que somente como "usuário". Você não precisa aprender a teoria das categorias
utilizada para que eles sejam úteis.
Muitos superestimam demais a dificuldade em se usar Lens. Qualquer um confortável com
*Functor*/*Foldable*/*Traversable* (ou até mesmo só com o primeiro) pode usar *lenses* e *prisms*
para tornar sua vida mais feliz.
Se você já fez algo como: `(fmap . fmap)` você está utilizando *lenses* na sua cabeça.
Eu recomendo estes dois tutoriais/introduções:
- [Um pequeno tutorial iniciante em lens](https://www.fpcomplete.com/school/to-infinity-and-beyond/pick-of-the-week/a-little-lens-starter-tutorial)
- [Lens: *Lenses*, *Folds* e *Traversals*](https://github.com/ekmett/lens#lens-lenses-folds-and-traversals)
Olhe aqui para mais informações: [Pacote Lens no hackage](http://hackage.haskell.org/package/lens).
# Esquemas de Recursão
Algumas das palavras \*-morfismo que você já ouviu tratam na verdade de recursão. Nota -
antes de se aventurar neste material, você deveria saber como implementar o `foldr` para listas
e para pelo menos mais uma estrutura de dados, como uma árvore. (*folds* são catamorfismos)
Saber como se implementa um `unfold` (anamorfismo) para a mesma estrutura vai facilitar
um pouco as coisas.
Este material se encaixa com *traversable* e *foldable*.
- [Uma introdução a esquemas de recursão](http://patrickthomson.ghost.io/an-introduction-to-recursion-schemes/)
- [Não tema o *cat*](http://fho.f12n.de/posts/2014-05-07-dont-fear-the-cat.html) (NT - em inglês existe um trocadilho
com o prefixo de catamorfismo - cat - e o termo cat (gato))
Boa demonstração de como hilomorfismo é a composição de catamorfismo e de anamorfismo.
- [Esquemas de Recursão](http://comonad.com/reader/2009/recursion-schemes/) - Este guia é
excelente.
- [Programação Funcional com bananas, *lenses*, envelopes e arame farpado(http://eprints.eemcs.utwente.nl/7281/01/db-utwente-40501F46.pdf)
- [Catamorfismos](https://www.fpcomplete.com/user/edwardk/recursion-schemes/catamorphisms)
# GHC Core e tunando a performance
- [Escreva Haskell tão rápido quanto C](write_haskell_as_fast_as_c.md)
- [Wiki do GHC: CoreSyn Type](https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/CoreSynType).
- [Hackage: GHC Core](https://hackage.haskell.org/package/ghc-core).
- [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
[MacLane](http://www.amazon.com/Categories-Working-Mathematician-Graduate-Mathematics/dp/0387984038).
Os livros-texto padrão sobre o tema.
- [Fundamentos Práticos para Linguagens de Programação, do Harper](http://www.cs.cmu.edu/~rwh/plbook/book.pdf) é a melhor introdução
à teoria dos tipos que já li.
- [Teoria dos tipos e Programação Funcional](http://www.cs.kent.ac.uk/people/staff/sjt/TTFP/).
## Posts elegantes do Stephen ("Como chegar até *monads*")
- [Adjunções](http://www.stephendiehl.com/posts/adjunctions.html).
- [Monads](http://www.stephendiehl.com/posts/monads.html).
# Outros tópicos divertidos
## Parametricidade, polimorfismo ad-hoc vs. paramétrico, teoremas livres
- [Parametricidade](tony_parametricity.pdf).
- [Fontes em TeX](https://github.com/tonymorris/parametricity/) para o texto acima.
- [Tornando o polimorfismo ad-hoc menos ad-hoc](http://swizec.com/blog/week-20-making-ad-hoc-polymorphism-less-ad-hoc/swizec/6564).
- [Teoremas de graça!](http://ttic.uchicago.edu/~dreyer/course/papers/wadler.pdf).
## Inicial e Final, DSLs, Finally Tagless
- [Codificação Final, Parte 1: Uma breve demonstração](http://creativelad.wordpress.com/2013/11/28/final-encodings-part-1-a-quick-demonstration/).
- [Transformando Valores Polimórficos](http://martijn.van.steenbergen.nl/journal/2009/10/18/transforming-polymorphic-values/).
- [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.
* [Parte 1: Codensidade](http://comonad.com/reader/2011/free-monads-for-less/).
* [Parte 2: Yoneda](http://comonad.com/reader/2011/free-monads-for-less-2/).
* [Parte 3: Produzindo IO](http://comonad.com/reader/2011/free-monads-for-less-3/).
## Proposições vs. Julgamentos (computação)
- [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 binários estaticamente
- [Linkagem Estática](https://wiki.haskell.org/Web/Literature/Static_linking)
- [Linkagem Estática com o GHC no Arch Linux](http://www.edofic.com/posts/2014-05-03-ghc-arch-static.html)
- [Linkando Estaticamente binários do Linux para ARM & MIPS](http://stackoverflow.com/questions/14270177/ghc-statically-linking-linux-binaries-for-arm-mips-processors)
- [Linkando Estaticamente GMP usando GHC e LLVM](http://stackoverflow.com/questions/10539857/statically-link-gmp-to-an-haskell-application-using-ghc-llvm)
# Lista de Leitura Estendida
> Alguns já foram incluídos neste guia
- [Lista de Leitura essencial ao Haskell](http://www.stephendiehl.com/posts/essential_haskell.html)
## Diálogos
> Hospedado [neste](dialogues.md) repositório.
Esses são tópicos bastante importantes e úteis. Olhe aqui para mergulhar mais fundo
numa variedade de tópicos.