Questa è la via che raccomando per imparare Haskell.
Questa è la strada che raccomando per imparare Haskell.
## Per chi non parla italiano
@ -16,57 +16,57 @@ Questa è la via che raccomando per imparare Haskell.
* [Türkçe](guide-tr.md)
#### Un consiglio: *non preoccupatevi se non capite qualcosa alla prima*. Andate avanti.
#### 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 [qui](http://webchat.freenode.net/).
Un client web per IRC e' 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 alla gente la voglia di partecipare.
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 solo la persona che le fa, non la persona che le riceve.
Crtitiche facili, in cui non mettete impegno, beneficiano soltanto voi e non la persona che le riceve.
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 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. 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 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à. 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 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 pavoneggiarmento che altro.
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).
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 abbiate sottili -ismi. Razzismo, sessismo, omofobia, transfobia, e altri tipi di pregiudizi non saranno tollerati
Non lasciate spazio ai sottilismi. 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 averlo reso pubblico, Hacker School.
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, come potete leggere nei report, il più recente è stato eseguito nel 2010. Il report è disponibile come
Haskell è un linguaggio di programmazione, e come potete leggere nei report, la versione più recente è stata rilasciata nel 2010. Il report è disponibile online:
[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ù.
[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) gestisce il progetto e la risoluzione delle dipendenze. È lo strumento che vi permetterà di installare i progetti, tipicamente ciascuno nel proprio sandbox.
[Cabal](https://www.haskell.org/cabal/download.html) e' 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 che versione installare.
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.
[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.
*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.
*Opzionale:* Potete anche aggiungere `.cabal-sandbox/bin` al vostro path. Il codice che state sviluppando attivamente sarà cosi' disponibile dalla linea di comando. Questo funziona solo quando la directory in cui siete è un sandbox di cabal.
## Debian
### Repository GHC per debian stable
### Repository GHC per debian stable
Se usate Debian stable, è più facile usare http://deb.haskell.org/. Per usarlo:
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`
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:
Se non state usando Debian stable, le stesse istruzioni che abbiamo indicato per Ubuntu fuzionano, ma dovrete eseguire un comando in più. Imediatamente 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 avete nel comando appena sopra.
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 esiste, allora `/etc/apt/sources.list` dovrebbe contenere una linea come questa:
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 `jessie` con `trusty` in questa linea.
Rimpiazzate quindi in quella linea `jessie` con `trusty`.
Su Gentoo, potete installare i singoli componenti della Haskell Platform
attraverso Portage. Se usate `ACCEPT_KEYWORDS=arch` (invece che
`ACCEPT_KEYWORDS=~arch`), Portage invece installerà versioni antiche delle varie cose Haskell. Tenendone di conto, se usate `ACCEPT_KEYWORDS=arch`, aggiungete le linee seguenti a `/etc/portage/package.keywords`.
`ACCEPT_KEYWORDS=~arch`), Portage installerà versioni piu' vecchie di Haskell. Tenendone di conto, se usate `ACCEPT_KEYWORDS=arch`, aggiungete le seguenti linee 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 più recenti. I backslash sono intenzionali.
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 directory home con `cabal-install`. Il prossimo passo è assicurarsi che quando lanciate `cabal` in un terminale, la vostra shell lanci la versione più recente che è nella directory home. Aggiugete le linee seguenti nel file di configurazione della vostra shell:
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
@ -190,8 +191,7 @@ 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`.
Una volta fatto tutto questo, dovrete installare i tool addizionali `alex` e `happy`.
```bash
$ cabal install alex happy
@ -203,18 +203,18 @@ Congratulazioni! Adesso avete una installazione di Haskell funzionante!
### 10.9
Installate [GHC per Mac OS X](http://ghcformacosx.github.io/), che include GHC e Cabal. Vi darà istruzioni su come installare GHC e Cabal nella vostra path una volta che avete copiato la .app da qualche parte sul disco fisso.
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 [questa tarball](https://www.haskell.org/platform/download/2014.2.0.0/ghc-7.8.3-x86_64-apple-darwin-r3.tar.bz2).
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.
- 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 richiede l'accesso alla directory di sistema 'Programmi'.
Non dimenticatevi di lanciare l'installer come amministratore, dato che e' richiesto l'accesso alla directory di sistema 'Programmi'.
## Altri utenti Linux
@ -228,25 +228,25 @@ Scaricate l'ultima distribuzione binaria di cabal e ghc:
## Il corso cis194 di Yorgey
> *Seguite questo per primo*, questa è la via che raccomando per il primo contatto con
> *Seguite questo per primo*, è la strada che raccomando per il primo approccio ad
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 Haskell basilare ma anche perché vi aiuterà a comprendere i parser combinators.
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, cominciate con il
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's
> 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 *critici* per sviluppare confidenza con gli usi comuni di Functor/Applicative/Monad/etc. in Haskell. La raccomandazione chiave della mia guida è seguire cis194 e poi NICTA, e questo è il percorso che seguo per insegnare Haskell a tutti.
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.
---
@ -256,7 +256,7 @@ Questo vi darà esperienza nell'implementare direttamente le astrazioni introdot
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 qualunque progetto Haskell finisce per richiedere 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, concorrenza, pipes e lenses.
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.
---
@ -266,7 +266,7 @@ Questo è il corso online di [Bryan O'Sullivan](https://github.com/bos) tratto d
[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 ottenere un'intuizione sull'utilità delle monadi. Altri hanno detto che gli è piaciuto molto. Forse un buon seguito per imparare gli idiomi in modo pratico, una volta che avete imparato le cose essenziali di Haskell?
sono ottimi per arrivare a capire l'utilità delle monadi stesse. Alcuni hanno detto che è piaciuto molto. Probabilmente e' 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?
- [Explain List Folds to Yourself](http://vimeo.com/64673035)
### Per imparare alcune Typeclass comuni
### Per imparare alcune Typeclass di uso comune
Utile per capire `Functor`, `Applicative`, `Monad`, `Monoid` e altre Typeclass in general, ma anche per certa Category Theory specifica ad Hask:
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)
- La [Typeclassopedia](http://www.haskell.org/haskellwiki/Typeclassopedia)
### Capire i messaggi di errore più comuni di Haskell
@ -291,15 +291,15 @@ Utile per capire `Functor`, `Applicative`, `Monad`, `Monoid` e altre Typeclass i
# 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 a alla laziness e alla normal form che abbia trovato. Usate altro materiale in più se non acquisite i concetti subito.
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 SO '[Does haskell have laziness?](http://stackoverflow.com/questions/13042353/does-haskell-have-tail-recursive-optimization)'
- 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
- La presentazione di [Johan Tibell](https://github.com/tibbe) su
[reasoning about laziness](http://www.slideshare.net/tibbe/reasoning-about-laziness).
## Breve dimostrazione
@ -326,35 +326,35 @@ let a = 1 * a -- non guarded, (*) è strict
- [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 impplementazione di unsafeDupablePerformIO
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 perche lo state token deve sempre essere usato linearmente (non
> duplicated o droppato), ma il type system non può garantire che accada. Clean, un altro
> linguaggio lazy come Haskell, ha uniqueness types (sono come i linear types
> e possibilmente diversi inmodi di cui non sono a conoscenza), e espongono
> dietro un tipo IO astratto perche' 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 typeclasse, Monoid, Functor e
> Non cominciate a imparali finché non capite typeclass, 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
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 molti interpreti cambiando solo la monade per cambiare la semantica può aiutarvi a capire in che cosa consiste.
Scrivere diversi interpreti cambiando solo la monade per cambiare la semantica può aiutarvi a capire in che cosa consiste.
- [Questa presentazioe](https://vimeo.com/73648150) di Tony dà un eccellente motivazione per i monad
- [Questa presentazione](https://vimeo.com/73648150) di Tony dà un eccellente motivazione per imparare i monad
Poi reimplementate `Control.Monad`. Funzioni come `mapM` o `sequence` sono buone opportunità per fare esercizio nello scrivere codice monadico generico.
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 una guida a questo processo, che include anche scrivere il vostro Applicative.
Il corso NICTA può essere usato come guida a questo scopo, che include anche lo scrivere la vostra typeclass Applicative.
Referenza:
@ -366,13 +366,13 @@ Referenza:
- [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://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf) (attenzione il codice riportato e' datato).
# Testare, test, specifiche, testing generativo e di properita'
- 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 semplice per imparae come lo streaming IO funziona in generale, la conoscenza è trasferibile a librerie come Pipes e Conduit
- [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 piu' complesse come Pipes e Conduit
# Parsing in Haskell
@ -447,45 +447,42 @@ haskell. Disponibile su [hackage](https://hackage.haskell.org/package/aeson) e
## Una FAQ fantastica
Oltre ad essere una guida eccezionale per vari tipi di cose, come i GADT,
questa guida copre anche alcune utili basi di Cabal
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 del'Inferno Cabal. Se installate fuori da un sandbox installerà il pacchetto nel vostro user package-db. Questa *non* è in genere una buona idea, con l'eccezione dei pacchetti di base come
Cabal, alex e happy. Nient'altro dovrebbe essere installato nei package-db dell'utente o globali, a meno che non sappiate cosa state facendo.
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 ne' tanto meno a livello globale, a meno che non sappiate cosa state facendo.
Alcune raccomandazioni per non cadere nell'inferno cabal sono disponibili
Alcune raccomandazioni per non cadere nel Cabal Hell sono disponibili
Per provare un pacchetto o cominciare un progetto, cominciate lanciando
Per provare un pacchetto o cominciare un progetto, iniziate lanciando
`cabal sandbox init` in una nuova directory.
In poche parole:
- Quando installate nuovi pacchetti, costruite progetti nuovi o pre-esistenti, o cominciate esperimenti usate sempre i sandbox.
- Quando installate nuovi pacchetti, create nuovi progetti o pre-esistenti, o cominciate esperimenti usate sempre i sandbox.
- Usate `cabal repl`per cominciare una istanza di ghci project-scoped
- Usate `cabal repl`invece per iniziare una istanza di ghci come project-scoped
Questo approccio basato suisandbox che suggerisco dovrebbe scamparvi 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 platform*, usate invece le istruzioni all'inizio della guida.
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
Per tutti gli utenti (di solito utenti di Yesod) che hanno problemi di build, considerate Stackage.
Tutti gli utenti (di solito utenti di Yesod) che hanno problemi di build potrebbero provare ad utilizzare Stackage.
Fate attenzione, questi post sono *lievemente obsoleti*: per esempio, adesso Hackage vanta nuovi modi di mostrare informazioni, di documentazione e sullo stato del build.
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 fare 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`, dovrete rimuovere tutti i vostri pacchetti e reinstallare prima di generare haddocks.
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 interpolato *da* cabal, non da voi, i parametri `html-location` e `content-location`
*devono essere fra apici* e inseriti in una shell o contenuti in uno
shell script. Non funzioneranno in un Makefile, perché crederanno di essere variabili di Make!
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
@ -537,7 +532,7 @@ Abbiamo l'imbarazzo della scelta! Ci sono tre scelte principali che raccomandere
* [Haste](http://haste-lang.org/) un compilatore da Haskell a JavaScript
- Il [compilatore](https://github.com/valderman/haste-compiler) su github.
- Un [demo](http://www.airpair.com/haskell/posts/haskell-tutorial-introduction-to-web-apps)
- 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)
@ -547,23 +542,22 @@ Abbiamo l'imbarazzo della scelta! Ci sono tre scelte principali che raccomandere
* [PureScript](http://www.purescript.org/)
- Non è strettamente Haskell come Haste e GHCJS, ma è una scelta popolare fra i programmatori Haskell
- Scritto in e ispirato da 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/)
## Che linguaggio scegliere per il frontend?
## Quale linguaggio scegliere per il frontend?
GHCJS e Haste sono entrambi interamente Haskell. GHCJS è compatibile con più pacchetti Haskell
packages rispetto a Haste, ma questo non sar' rilevante per molti progetti frontend. PureScript non è per niente Haskell, so quindi non potete condividere il codice fra frontend e backend.
GHCJS e Haste sono entrambi interamente compatibili con Haskell. GHCJS è compatibile con un numero maggiore di pacchetti Haskell rispetto a Haste, ma questo non e' rilevante per molti progetti frontend. Al constrario, PureScript non è Haskell, per tanto non potrete condividere il codice fra frontend e backend.
GHCJS ha la runtime più abbondante, a 100kb (luite ci sta lavorando). Haste e PureScript sono competitivi.
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), GHCJS
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 unottima scelta e possono funzionare per la maggioranza dei progetti frontend.
Tutti e tre sono un'ottima scelta e possono funzionare per la maggioranza dei progetti frontend.
# Per una comprensione più profonda di laziness, NF, WHNF
# Per una comprensione più profonda della laziness, NF, WHNF
- [Notes on lambda calculus](https://vec.io/posts/notes-on-lambda-calculus).
@ -579,22 +573,21 @@ Tutti e tre sono un ottima scelta e possono funzionare per la maggioranza dei pr
# Parallelismo/Concorrenza
- Il libro [Parallel and Concurrent Programming in Haskell](http://chimera.labs.oreilly.com/books/1230000000929). This
di Simon Marlow è probabilmente il migliore che ho mai letto sull'argomento.
- 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 & incremental development di un applicazione multi-threaded in Haskell.
- 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.
Una volta che trovate a vostro agio con Haskell, è molto utile imparare Lenti e
Prismi, anche se solo come "utente". Non avete bisogno di capire le categorie sottostanti
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 le Lenti è generalmente sovrastimata. Chiunque sia a suo agio con Functor/Foldable/Traversable (o anche solo il primo) può usare lenti e prismi per rendersi la vita più facile.
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 le lenti nella vostra mente.
Se vi è capitato di fare qualcosa come: `(fmap . fmap)` stavate usando mentalmente le 'lenti'.
Raccomando questi due tutorial/introduzioni:
@ -606,9 +599,9 @@ Leggete questo per maggiori informazioni: [pacchetto Lens su hackage](http://hac
# Schemi di ricorsione
Alcune delle pazze parole che finiscono con \*-morfisma di cui avete sentito parlare in effetti riguardano la ricorsione. NB - prima di attaccare questo materiale 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 (anamorfisma) per le stesse strutture dati è complementare.
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.
This material dovetails with traversable and foldable.
Questo materiale si compenetra con traversable e foldable.
- [An introduction to recursion schemes](http://patrickthomson.ghost.io/an-introduction-to-recursion-schemes/)
@ -647,7 +640,7 @@ Se volete imparare di più su tipi e teoria delle categorie:
- [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), Includes some practical examples.
- [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.
@ -670,7 +663,7 @@ Se volete imparare di più su tipi e teoria delle categorie:
# Altri argomenti divertenti
## Parametricità, ad-hoc vs. polimorfismo parametrico, teoremi liberi
## Parametricità, ad-hoc vs. polimorfismo parametrico e teoremi liberi
- [Parametricity](tony_parametricity.pdf).
@ -680,7 +673,7 @@ Se volete imparare di più su tipi e teoria delle categorie:
- [Theorems for Free!](http://ttic.uchicago.edu/~dreyer/course/papers/wadler.pdf).
## Iniziali e Finali, DSL, Finally Tagless
## 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/).
@ -694,7 +687,7 @@ Se volete imparare di più su tipi e teoria delle categorie:
- [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 interessante.
- [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
@ -743,7 +736,7 @@ Se volete imparare di più su tipi e teoria delle categorie:
## Dialoghi
> Disponibile in questa repository [qui](dialogues.md).
> Disponibile in questo repository [qui](dialogues.md).
Questi sono in realtà importanti e utili. Leggeteli per approfondimenti su una varietà di argomenti.
Nicola Bonelli
10 years ago