Non descrivete nulla con parole come "facile" o "banale". Chi legge si sentirà stupido perché per lui le cose che definite come triviali possono aver richiesto molto impegno. Spesso chi impara lentamente impara più profondamente, è una cosa che dovremmo celebrare invece!
Non fate finta di essere sorpresi. Non fate i sorpresi quando qualcuno vi dice che non sa qualcosa. Lo farete sentire stupido e non avrete ottenuto niente a parte sentirvi più furbi.
Non dite beh-in realtà. Quando qualcuno dice che qualcosa è quasi - ma non completamente corretto 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 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 pavoneggiarmenti e non di verità.
Non dite agli altri cosa devono fare. Se qualcuno sta completando un esercizio non dovreste interromperlo a sprazzi con continui consigli. Lasciate che trovino la loro strada a meno che non chiedano esplicitame. Evitare interruzioni è [uno degli obiettivi fondamentali di #haskell-beginners](http://chrisdone.com/posts/teaching).
[GHC](http://www.haskell.org/ghc/) è il modo più popolare per lavorare in Haskell. Include un compilatore, una REPL (interprete), gestione automatica delle librerie, e altre cose in più.
## Cabal
[Cabal](https://www.haskell.org/cabal/download.html) gestisce il progetto e la risoluzione delle dipendenze. È lo strumento che vi permetterà di installare i progetti, 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 che 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
*Opzionale:* Potete anche aggiungere `.cabal-sandbox/bin` alla vostra path. Il codice che state sviluppando attivamente vi sarà 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 usate Debian stable, è più facile usare 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 stable, le stesse istruzioni che abbiamo indicato per Ubuntu fuzioneranno, ma dovrete eseguire un comando in più. Imediatamente dopo
`sudo add-apt-repository -y ppa:hvr/ghc` è stato eseguito 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 avete nel comando appena sopra.
Se, per qualche ragione, il file `/etc/apt/sources.list.d/hvr-ghc-jessie.list` non esiste, allora `/etc/apt/sources.list` dovrebbe contenere una linea come questa:
deb http://ppa.launchpad.net/hvr/ghc/ubuntu jessie main
Rimpiazzate `jessie` con `trusty` in questa linea.
questo ghc non puo' essere installato in parallelo con il ghc di Fedora/EPEL.
## Arch Linux
Per installare Haskell dalle repo 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 invece installera' versioni antiche delle varie cose Haskell. Tenendone di conto, se usate `ACCEPT_KEYWORDS=arch`, aggiungete le linee seguenti a `/etc/portage/package.keywords`.
Gentoo tiene una versione "stabile" (leggi: vecchia) di `cabal-install` nell'albero di Portage, quindi vorrete usare `cabal-install` per installare le versioni piu' recenti. 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 directory home con `cabal-install`. Il prossimo passo e' assicurarsi che quando lanciate `cabal` in un terminale, la vostra shell lanci la versione piu' recente che e' nella directory home. 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, e' molto probabile che la vostra shell sia Bash. Se usate Bash, il file che dovete editare e' `~/.bashrc`. se usate Z-shell, il file e' `~/.zshrc`. Potete lanciare il seguete comando per sapere qual'e' la vostra shell.
```bash
echo $SHELL | xargs basename
```
Io uso zsh, quindi il comando restituisce `zsh` quando lo lancio.
Una volta fatto tutto questo, vorrete 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. Vi dara' istruzioni su come installare GHC e Cabal nella vostra 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 [questa 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)
e' in grado di compilare `network` e altro. E' tecnicamente in beta ma dovrebbe funzionare per gli scopi di chiuque legga questa guida.
Non dimenticatevi di lanciare l'installer come amministratore, dato che richiede l'accesso alla directory di sistema 'Programmi'.
## Altri utenti Linux
Scaricate l'ultima distribuzione binaria di cabal e ghc:
Il corso di [Brent Yorgey](https://byorgey.wordpress.com) e' il migliore che ho trovato finora. Questo corso ha valore non solo perche' vi rende in grado di scrivere Haskell basilare ma anche perche' vi aiutera' a comprendere i parser combinators.
L'unica ragione per cui non dovreste cominciare con cis194 e' se non siete programmatori o se non avete molta esperienza. In questo caso, cominciate con il
[libro di Thompson](http://www.haskellcraft.com/craft3e/Home.html) e poi passate a cis194.
---
## Il corso NICTA
> Questo e' il corso che raccomando dopo cis194 di Yorgey's
Disponibile su github [qui](https://github.com/NICTA/course).
Questo vi dara' esperienza nell'implementare direttamente le astrazioni introdotte in cis194, questi esercizi sono *critici* per sviluppare confidenza con gli usi comuni di Functor/Applicative/Monad/etc. in Haskell. La raccomandazione chiave della mia guida e' seguire cis194 e poi NICTA, e questo e' il percorso che seguo per insegnare Haskell a tutti.
Questo e' il corso online di [Bryan O'Sullivan](https://github.com/bos) tratto dal corso che insegna a Stanford. Se non sapete chi e' date un'occhiata alla meta' delle librerie che qualunque progetto Haskell finisce per richiedere e ci troverete il suo nome. Sa avete gia' seguito il corso di Yorgey sono particolarmente rilevanti i moduli sui phantom types, il flusso di controllo delle informazioni, le estensioni del linguaggio, concorrenza, 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 (e' un libro spesso). I capitoli sul parsing e sulle monadi
sono ottimi per ottenere un'intuizione sull'utilita' delle monadi. Altri hanno detto che gli e' piaciuto molto. Forse un buon seguito 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?
- [Come imparare i List Fold](http://vimeo.com/64673035)
### Per imparare alcune Typeclass comuni
Utile per capire `Functor`, `Applicative`, `Monad`, `Monoid` e altre Typeclass in general, ma anche per certa Category Theory specifica ad Hask:
- LA [Typeclassopedia](http://www.haskell.org/haskellwiki/Typeclassopedia)
### Capire i messaggi di errore piu' comuni di Haskell
- [Capire i messaggi di errore piu' comuni](http://ics.p.lodz.pl/~stolarek/_media/pl:research:stolarek_understanding_basic_haskell_error_messages.pdf)
---
# Laziness, strictness, guarded recursion
- Il libro di Marlow [book](http://chimera.labs.oreilly.com/books/1230000000929/ch02.html)
sul parallelismo e la concorrenza ha una delle migliori introduzioni a alla laziness e alla normal form che abbia trovato. Usate altro materiale in piu' se non acquisite i concetti subito.
- [Piu' punti per la 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 SO '[Haskell ha laziness?](http://stackoverflow.com/questions/13042353/does-haskell-have-tail-recursive-optimization)'
- LA presentazione di [Johan Tibell](https://github.com/tibbe) su
[ragionare sulla laziness](http://www.slideshare.net/tibbe/reasoning-about-laziness).
## Breve dimostrazione
```haskell
let a = 1 : a -- guarded recursion, (:) e' lazy su di esso si puo' usare pattern matching.
let (v : _) = a
> v
1
> head a -- head a == v
1
let a = 1 * a -- non guarded, (*) e' strict
> a
*** Exception: <<loop>>
```
# IO
- [Evaluation order e State tokens](https://www.fpcomplete.com/user/snoyberg/general-haskell/advanced/evaluation-order-and-state-tokens)
- [Svelare il mistero della monade IO](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 per 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 impplementazione 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 perche lo state token deve sempre essere usato linearmente (non
> duplicated o droppato), ma il type system non puo' garantire che accada. Clean, un altro
> linguaggio lazy come Haskell, ha uniqueness types (sono come i linear types
> e possibilmente diversi in modi 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 finche' non capite typeclasse, Monoid, Functor e
> Applicative!
Implementate per conto vostro le monadi nella libreria standard ( List, Maybe, Cont, Error, Reader,
Writer, State ) per capirli meglio. Poi potreste scrivere un interprete monadico per un small expression language usando la paper
[Monad Transformer Passo dopo Passo](http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf) (menzionata in 'monad transformers' qui sotto).
Scrivere molti interpreti cambiando solo la monade per cambiare la semantica puo' aiutarvi a capire in che cosa consiste.
- [Questa resentazioe](https://vimeo.com/73648150) di Tony da' un eccellente motivazione per i monad
Poi reimplementate `Control.Monad`. Funzioni come `mapM` o `sequence` sono buone opportunita' per fare esercizio nello scrivere codice monadico generico.
Il corso NICTA puo' essere usato come una guida a questo processo, che include anche scrivere il vostro 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
- [Un'introduzione gentile ai Monad Transformers](https://github.com/kqr/gists/blob/master/articles/gentle-introduction-monad-transformers.md).
- [Monad transformers passo dopo passo](http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf) (warning, code out of date).
- [Writing your own micro-Parsec](http://olenhad.me/articles/monadic-parsers/)
## Parsing and generating JSON
Aeson is the standard [JSON](https://json.org) parsing solution in
haskell. Available from [hackage](https://hackage.haskell.org/package/aeson) and
[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)
- [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).
- The [graphs package](https://hackage.haskell.org/package/graphs).
- [SO question about 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).
- The [haskell wikibook](http://en.wikibooks.org/wiki/Haskell/Category_theory)
has nice diagrams
- [Category Theory](http://www.haskell.org/haskellwiki/Category_theory) on
haskellwiki, also has good links to other resources
- [Categories from scratch](http://science.raphael.poss.name/categories-from-scratch.html), Includes some practical examples.
- Pierce's [Great Works in PL](http://www.cis.upenn.edu/~bcpierce/courses/670Fall04/GreatWorksInPL.shtml) list.
## Books
- [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) Kmett's recommendations
- [Awodey](http://ukcatalogue.oup.com/product/9780199237180.do) and
[MacLane](http://www.amazon.com/Categories-Working-Mathematician-Graduate-Mathematics/dp/0387984038). The standard textbooks on category theory.
- [Harper's Practical Foundations for Programming Languages](http://www.cs.cmu.edu/~rwh/plbook/book.pdf) is the best PL focused intro to type theory I've read.
- [Type theory and Functional Programming](http://www.cs.kent.ac.uk/people/staff/sjt/TTFP/).
- [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)
# Dependent typing
- [Grokking sum types, value constructors, and type constructors](http://bitemyapp.com/posts/2014-04-05-grokking-sums-and-constructors.html) squint hard.
- [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)
