@ -6,7 +6,7 @@ This is my recommended path for learning Haskell.
Our IRC channel is `#haskell-beginners` on Freenode.
IRC web client here: http://webchat.freenode.net/
IRC web client [here](http://webchat.freenode.net/).
## Community Guidelines
@ -18,47 +18,67 @@ Be nice above all else!
## What are Haskell, GHC, and Cabal?
Haskell is a programming language as laid out in the reports, most recent one being in 2010. http://www.haskell.org/onlinereport/haskell2010/
Haskell is a programming language as laid out in the reports, most recent one
being in 2010. [onlinereport](http://www.haskell.org/onlinereport/haskell2010/)
GHC is the most popular compiler for Haskell and is what you'll install along with Cabal. Cabal is the project and dependency management tool used with GHC. You almost definitely want both if you're going to start writing Haskell.
GHC is the most popular compiler for Haskell and is what you'll install along
with Cabal. Cabal is the project and dependency management tool used with
GHC. You almost definitely want both if you're going to start writing Haskell.
Cabal is equivalent to Ruby's Bundler, Python's pip, Node's NPM, Maven, etc. GHC manages packaging itself, Cabal chooses what versions to install.
Cabal is equivalent to Ruby's Bundler, Python's pip, Node's NPM, Maven, etc. GHC
manages packaging itself, Cabal chooses what versions to install.
## Getting started
### Ubuntu
This PPA is excellent and is what I use on all my Linux dev and build machines: http://launchpad.net/~hvr/+archive/ghc
[This](http://launchpad.net/~hvr/+archive/ghc) PPA is excellent and is what I
use on all my Linux dev and build machines.
Specifically:
- `sudo apt-get update`
- **12.04 and below** -> `sudo apt-get install python-software-properties`
- **12.10 and above** -> `sudo apt-get install software-properties-common`
Then add `~/.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` to your PATH (bash_profile, zshrc, bashrc, etc)
Then add
`~/.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` to your PATH (bash_profile, zshrc, bashrc, etc)
*Optional* You could also add `.cabal-sandbox/bin` to your path. Code that you are actively developing will be available to you from the command line.
This only works when your current working directory is a cabal sandbox.
*Optional:* You could also add `.cabal-sandbox/bin` to your path. Code that you
are actively developing will be available to you from the command line. This
only works when your current working directory is a cabal sandbox.
### Debian
#### GHC Repository for debian stable
If you use Debian stable, it is easier to use http://deb.haskell.org/. To use this:
If you use Debian stable, it is easier to use http://deb.haskell.org/. To use it:
- Add the line `deb http://deb.haskell.org/stable/ ./` to `/etc/apt/sources.list`
- Add the key to avoid warnings with `GET http://deb.haskell.org/deb.haskell.org.gpg-key | apt-key add -`
- Run `sudo apt-get update`
- Run `sudo apt-get install ghc-7.8.3 happy alex cabal-install`
```bash
$ GET http://deb.haskell.org/deb.haskell.org.gpg-key | apt-key add - # Add the key to avoid warnings
$ sudo apt-get update
$ sudo apt-get install ghc-7.8.3 happy alex cabal-install
```
#### Using Ubuntu PPA
If you're not using stable, you can follow the same steps as Ubuntu, but has to execute an additional command. Immediately after `sudo add-apt-repository -y ppa:hvr/ghc` is ran, run:
- `sudo sed -i s/jessie/trusty/g /etc/apt/sources.list.d/hvr-ghc-jessie.list`
If you're not using stable, you can follow the same steps as Ubuntu, but will
have to execute an additional command. Immediately after
`sudo add-apt-repository -y ppa:hvr/ghc` is executed run:
For other Debian versions, just replace all occurences of "jessie" with your version name in the command above.
```bash
sudo sed -i s/jessie/trusty/g /etc/apt/sources.list.d/hvr-ghc-jessie.list
```
For other Debian versions, just replace all occurences of "jessie" with your
version name in the command above.
If, for some reason, the file `/etc/apt/sources.list.d/hvr-ghc-jessie.list` does
not exist, then `/etc/apt/sources.list` should contain a line like this:
@ -67,24 +87,35 @@ not exist, then `/etc/apt/sources.list` should contain a line like this:
deb http://ppa.launchpad.net/hvr/ghc/ubuntu jessie main
```
Replace "jessie" with "trusty" in this line.
Replace `jessie` with `trusty` in this line.
#### Manual compilation
You can follow the guide written for Mac OS X: http://www.davesquared.net/2014/05/platformless-haskell.html. Notes:
- set your prefix accordingly when configuring ghc
- instead of grabbing the `cabal-install` binary, grab the source and then run `bootstrap.sh` script.
I use zsh, so that command outputs `zsh` when I run it.
Once you do all of that, you'll want to install the additional tools `alex` and
`happy`.
cabal install alex happy
```bash
$ cabal install alex happy
```
Congratulations! You now have a working Haskell installation!
@ -137,21 +178,22 @@ Congratulations! You now have a working Haskell installation!
#### 10.9
Install the GHC for Mac OS X app, which includes GHC and Cabal. It provides instructions on how to add GHC and Cabal to your path after you've dropped the .app somewhere.
- http://ghcformacosx.github.io/
Install the [GHC for Mac OS X](http://ghcformacosx.github.io/) app, which
includes GHC and Cabal. It provides instructions on how to add GHC and Cabal to
your path after you've dropped the `.app` somewhere.
#### 10.6-10.8
Do the binary distribution install described below with this tarball:
Do the binary distribution install described below with [this tarball](https://www.haskell.org/platform/download/2014.2.0.0/ghc-7.8.3-x86_64-apple-darwin-r3.tar.bz2).
### Windows
- http://neilmitchell.blogspot.com/2014/12/beta-testing-windows-minimal-ghc.html is able to compile `network` et al. Technically in beta but should work for the purposes of anybody reading this guide.
- The [windows minimal GHC installer](http://neilmitchell.blogspot.com/2014/12/beta-testing-windows-minimal-ghc.html)
is able to compile `network` et al. Technically in beta but should work for
the purposes of anybody reading this guide.
Don't forget to run the installer as administrator as it will want to install in your Program Files.
Don't forget to run the installer as administrator as it will want to install in
your Program Files.
### Other Linux users
@ -159,29 +201,34 @@ Download the latest binary distributions for cabal and ghc:
#### GHC
GHC is the most popular way to work in the Haskell language. It includes a compiler, REPL (interpreter), package management, and other things besides.
- http://www.haskell.org/ghc/
[GHC](http://www.haskell.org/ghc/) is the most popular way to work in the
Haskell language. It includes a compiler, REPL (interpreter), package
management, and other things besides.
#### Cabal
Cabal does project management and dependency resolution. It's how you'll install projects, typically into their own sandbox.
- https://www.haskell.org/cabal/download.html
[Cabal](https://www.haskell.org/cabal/download.html) does project management and
dependency resolution. It's how you'll install projects, typically into their
own sandbox.
#### Detailed manual install guide for Mac OS X
You don't need this if you use the .app, but if it doesn't work for you, try this with the binary distribution.
> *Do this first*, this is the primary way I recommend being introduced to Haskell.
http://www.seas.upenn.edu/~cis194/spring13/index.html Brent Yorgey's course is the best I've found so far and replaces both Yann Esposito's HF&H. This course is valuable as it will not only equip you to write basic Haskell but also help you to understand parser combinators.
[Brent Yorgey](https://byorgey.wordpress.com)'s course is the best I've found so
far and replaces Yann Esposito's HF&H. This course is valuable as it will not
only equip you to write basic Haskell but also help you to understand parser
combinators.
<<<<<<<Updatedupstream
The only reason you shouldn't start with cis194 is if you are not a programmer or are an inexperienced one. If that's the case, start with [Thompson's book](http://www.haskellcraft.com/craft3e/Home.html) and then transition to cis194.
After you're done with cis194, move on to the NICTA Course.
@ -191,109 +238,156 @@ After you're done with cis194, move on to the NICTA Course.
## Exercises for practice (do this after cis194)
You should do this course after cis194: https://github.com/NICTA/course/
=======
The only reason you shouldn't start with cis194 is if you are not a programmer
or are an inexperienced one. If that's the case, start with
[Learn You a Haskell](http://learnyouahaskell.com/) and transition to cis194.
If you are not new to programming, Learn You A Haskell and
[Real World Haskell](http://book.realworldhaskell.org/) are recommended
primarily as supplemental references for completing the cis194 course. RWH has
some additional material that LYAH does not that is useful to people using
Haskell in production as well.
---
## Supplementary course that provides more material on intermediate topics
This is Bryan O'Sullivan's online course from the class he teaches at Stanford. If you don't know who he is, take a gander at half the libraries any Haskell application ends up needing and his name is on it. Of particular note if you've already done the Yorgey course are the modules on phantom types, information flow control, language extensions, concurrency, pipes, and lenses.
> Provides more material on intermediate topics
- http://www.scs.stanford.edu/14sp-cs240h/
This is [Bryan O'Sullivan](https://github.com/bos)'s online course from the
class he teaches at Stanford. If you don't know who he is, take a gander at half
the libraries any Haskell application ends up needing and his name is on it. Of
particular note if you've already done the Yorgey course are the modules on
phantom types, information flow control, language extensions, concurrency,
pipes, and lenses.
---
[Learn You a Haskell for Great Good (LYAH)](http://learnyouahaskell.com) and
[Real World Haskell](http://book.realworldhaskell.org) (Thanks bos!) are
available online.
I recommend RWH as a reference (thick book). The chapters for parsing and monads
are great for getting a sense for where monads are useful. Other people have
said that they've liked it a lot. Perhaps a good follow-up for practical idioms
after you've got the essentials of Haskell down?
### For understanding list and fold
- http://vimeo.com/64673035
- [Explain List Folds to Yourself](http://vimeo.com/64673035)
### For learning some common typeclasses
Useful for understanding `Functor`, `Applicative`, `Monad`, `Monoid` and other typeclasses in general but also some Hask-specific category theory:
Cabal Hell was a problem for Haskell users before the introduction of
sandboxes. Installing outside of a sandbox will install into your user
package-db. This is *not* a good idea except for foundational packages like
Cabal, alex, and happy. Nothing else should be installed in the user or global
package-dbs unless you know what you're doing.
Cabal Hell was a problem for Haskell users before the introduction of sandboxes. Installing outside of a sandbox will install into your user package-db. This is *not* a good idea except for foundational packages like Cabal, alex, and happy. Nothing else should be installed in the user or global package-dbs unless you know what you're doing.
Some best practices for avoiding cabal hell are available [here](http://softwaresimply.blogspot.com/2014/07/haskell-best-practices-for-avoiding.html).
To experiment with a package or start a project, begin by doing `cabal sandbox init` in a new directory.
To experiment with a package or start a project, begin by doing
`cabal sandbox init` in a new directory.
Put briefly:
- Always use sandboxes for installing new packages, building new or existing projects, or starting experiments
- Always use sandboxes for installing new packages, building new or existing
projects, or starting experiments
- Use `cabal repl` to start a project-scoped ghci instance
The sandbox-based approach I suggest should avoid package-dependency problems, but it's incompatible with the way the Haskell Platform provides pre-built packages. If you're still learning Haskell and don't understand how ghc-pkg and Cabal work, *avoid Platform* and instead use the install instructions earlier in the guide.
The sandbox-based approach I suggest should avoid package-dependency problems,
but it's incompatible with the way the Haskell Platform provides pre-built
packages. If you're still learning Haskell and don't understand how ghc-pkg and
Cabal work, *avoid platform* and instead use the install instructions earlier in
the guide.
## Search code by type signature
The Hoogle search engine can search by type:
The [Hoogle search engine](http://www.haskell.org/hoogle/) can search by type.
Note that these posts are slightly out of date: for example, now
Hackage sports shiny new info with documentation info and build status.
Note that these posts are *slightly out of date*: for example, now Hackage sports
shiny new info with documentation info and build status.
### What you really need to know
In order to have haddocks include documentation for related packages, you have to set documentation: True in your ~/.cabal/config. If it was left on the default (False) or set to False, you'll have to delete all your packages and reinstall before generating haddocks.
In order to have haddocks include documentation for related packages, you have
to set `documentation: True` in your `~/.cabal/config`. If it was left on the
default (`False`) or set to `False`, you'll have to delete all your packages and
reinstall before generating haddocks.
The other thing to keep in mind is that due to the way the $pkg parameter gets interpolated *by* cabal, not by you, the html-location and content-location parameters must be in single quotes and entered into a shell or contained in a shell script. They will not work in a Makefile, because it will think they are Make variables!
The other thing to keep in mind is that due to the way the `$pkg` parameter gets
interpolated *by* cabal, not by you, the `html-location` and `content-location`
parameters *must be in single quotes* and entered into a shell or contained in a
shell script. They will not work in a Makefile, because it will think they are
Make variables!
```bash
#!/usr/bin/env sh
@ -301,86 +395,108 @@ The other thing to keep in mind is that due to the way the $pkg parameter gets i
If you're as big a fan of TravisCI as I am, then I *strongly* recommend you look at using https://github.com/hvr/multi-ghc-travis as the basis of the travis.yml for your Haskell projects.
If you're as big a fan of [TravisCI](https://travis-ci.org) as I am, then I
*strongly* recommend you take a look at
[multi-ghc-travis](https://github.com/hvr/multi-ghc-travis) by as the basis of
the `travis.yml` for your Haskell projects.
## Fun Stuff
After you're comfortable with Haskell, strongly consider learning Lenses and Prisms, even if just as a "user". You don't need to understand the underlying category for it to be useful.
After you're comfortable with Haskell, strongly consider learning Lenses and
Prisms, even if just as a "user". You don't need to understand the underlying
category for it to be useful.
Seen here: http://hackage.haskell.org/package/lens
Look here: [Lens package on hackage](http://hackage.haskell.org/package/lens).
## Frontend/JavaScript
We have an embarrassment of riches! There are three main choices I would recommend:
We have an embarrassment of riches! There are three main choices I would
recommend:
- Haste
- http://haste-lang.org/
- https://github.com/valderman/haste-compiler
- http://www.airpair.com/haskell/posts/haskell-tutorial-introduction-to-web-apps Excellent demo of Haste for an example project
* [Haste](http://haste-lang.org/) a javascript to haskell compiler
- The [compiler](https://github.com/valderman/haste-compiler) on github.
- An excellent [demo](http://www.airpair.com/haskell/posts/haskell-tutorial-introduction-to-web-apps) of Haste with an example project
- [Functional Reactive Web Interfaces with GHCJS and Sodium](http://weblog.luite.com/wordpress/?p=127)
- PureScript (not strictly Haskell like Haste and GHCJS, but a popular choice among Haskellers)
- http://www.purescript.org/
- http://try.purescript.org/
- http://www.christopherbiscardi.com/2014/06/22/getting-started-with-purescript/ Great guide for getting started
* [PureScript](http://www.purescript.org/)
- Not strictly Haskell like Haste and GHCJS, but a popular choice among
Haskellers
- Written in and inspired by haskell
- Try purescript in you browser [here](http://try.purescript.org/)
- Great guide for [getting started](http://www.christopherbiscardi.com/2014/06/22/getting-started-with-purescript/)
### Which frontend language do I use?
GHCJS and Haste are both fully Haskell. GHCJS will work with more Haskell packages than Haste, but this doesn't affect a lot of frontend projects. PureScript isn't Haskell at all, so direct code sharing with your backend will not work.
GHCJS and Haste are both fully Haskell. GHCJS will work with more Haskell
packages than Haste, but this doesn't affect a lot of frontend
projects. PureScript isn't Haskell at all, so direct code sharing with your
backend will not work.
GHCJS has the fattest runtime payload overhead at about 100kb (luite is working on this). Haste and PureScript are competitive.
GHCJS has the fattest runtime payload overhead at about 100kb (luite is working
on this). Haste and PureScript are competitive.
PureScript has the best JS tooling integration (uses gulp/grunt/bower), GHCJS and Haste integrate better with Haskell's tooling (Cabal).
PureScript has the best JS tooling integration (uses gulp/grunt/bower), GHCJS
and Haste integrate better with Haskell's tooling (Cabal).
All three are great choices and will work for most frontend projects.
## Parsing in Haskell
- Parser combinator tutorial for Haskell using Parsec: https://github.com/JakeWheat/intro_to_parsing
- [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)
- http://chimera.labs.oreilly.com/books/1230000000929/ch02.html Marlow's book about parallelism and concurrency has one of the best introductions to laziness and normal form I've found. Use other material too if it doesn't stick immediately.
- [Lazy evaluation of Haskell](http://www.vex.net/~trebla/haskell/lazy.xhtlm)
## Parallelism/Concurrency
- http://chimera.labs.oreilly.com/books/1230000000929 This book by Simon Marlow is probably the best I've ever read on the topics of Parallelism and Concurrency:
- [Parallel and Concurrent Programming in Haskell](http://chimera.labs.oreilly.com/books/1230000000929). This book by Simon Marlow is probably the best I've ever read on the topics of Parallelism and Concurrency.
- http://kukuruku.co/hub/haskell/haskell-testing-a-multithread-application A thorough walk-through on testing & incremental development of a multi-threaded application in Haskell
- A thorough [walk-through](http://kukuruku.co/hub/haskell/haskell-testing-a-multithread-application) on testing & incremental development of a multi-threaded application in Haskell
People vastly overestimate the difficulty of using Lens. Anybody comfortable with Functor/Foldable/Traversable (or even just the first one) can leverage lenses and prisms to make their life happier.
People vastly overestimate the difficulty of using Lens. Anybody comfortable
with Functor/Foldable/Traversable (or even just the first one) can leverage
lenses and prisms to make their life happier.
If you've ever done something like: `(fmap . fmap)` you were "lensing" in your head.
If you've ever done something like: `(fmap . fmap)` you were "lensing" in your
- [Lens: Lenses, Folds and Traversals](https://github.com/ekmett/lens#lens-lenses-folds-and-traversals)
## Monads and monad transformers
### Do not do these until you understand typeclasses, Monoid, Functor, and Applicative!
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 paper.
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)
paper (mentioned in 'monad transformers' below).
Writing many interpreters by just changing the monad to change the semantics can help convey what's going on.
Writing many interpreters by just changing the monad to change the semantics can
help convey what's going on.
- https://vimeo.com/73648150 This talk by Tony excellently motivates monad transformers
- [This talk](https://vimeo.com/73648150) by Tony excellently motivates monad
transformers.
Also, reimplement Control.Monad. Functions like `mapM` or `sequence` are good opportunities to practice writing generic monadic code.
Also, reimplement `Control.Monad`. Functions like `mapM` or `sequence` are good
opportunities to practice writing generic monadic code.
The NICTA course can be used as a guide to this process, which will also involve writing your own Applicative as well.
- This [tutorial](https://github.com/kazu-yamamoto/unit-test-example/blob/master/markdown/en/tutorial.md) by Kazu Yamamoto is fantastic.
- https://github.com/jwiegley/simple-conduit Good simple library for learning how streaming IO works in general, knowledge transferrable to libraries like Pipes and Conduit
- [Simple-Conduit](https://github.com/jwiegley/simple-conduit): Good simple
library for learning how streaming IO works in general, knowledge
transferrable to libraries like Pipes and Conduit
## Recursion Schemes
Some of the crazy *-morphism words you've heard are actually about recursion. NB - before tackling this material you should know how to implement foldr for lists and at least one other data structure, such as a tree. (folds are catamorphisms) Knowing how to implement an unfold (anamorphism) for the same will round things out a bit.
Some of the crazy \*-morphism words you've heard are actually about
recursion. NB - before tackling this material you should know how to implement
foldr for lists and at least one other data structure, such as a tree. (folds
are catamorphisms) Knowing how to implement an unfold (anamorphism) for the same
will round things out a bit.
This material dovetails with traversable and foldable.
- http://www.cs.cmu.edu/~rwh/plbook/book.pdf Harper's Practical Foundations for Programming Languages is the best PL focused intro to type theory I've read.
- [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.
- [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
- [Evaluation order and State tokens](https://www.fpcomplete.com/user/snoyberg/general-haskell/advanced/evaluation-order-and-state-tokens)
Comment from Reddit thread by `glaebhoerl`
Interesting side note: GHC needs to hide the state token representation behind
an abstract IO type because the state token must always be used linearly (not
duplicated or dropped), but the type system can't enforce this. Clean, another
lazy Haskell-like language, has uniqueness types (which are like linear types
and possibly different in ways I'm not aware of), and they expose the
World-passing directly and provide a (non-abstract) IO monad only for
convenience.
Interesting side note: GHC needs to hide the state token representation behind an abstract IO type because the state token must always be used linearly (not duplicated or dropped), but the type system can't enforce this. Clean, another lazy Haskell-like language, has uniqueness types (which are like linear types and possibly different in ways I'm not aware of), and they expose the World-passing directly and provide a (non-abstract) IO monad only for convenience.
- [Unraveling the mystery of the IO monad](http://blog.ezyang.com/2011/05/unraveling-the-mystery-of-the-io-monad/).
- http://blog.jle.im/entry/first-class-statements
- [First class "statements"](http://blog.jle.im/entry/first-class-statements).
- http://hackage.haskell.org/package/base-4.7.0.1/docs/System-IO-Unsafe.html#v:unsafePerformIO Read the docs and note implementation of unsafeDupablePerformIO
- [Haddocks for System.IO.Unsafe.unsafePerformIO](http://hackage.haskell.org/package/base-4.7.0.1/docs/System-IO-Unsafe.html#v:unsafePerformIO)
Read the docs and note implementation of unsafeDupablePerformIO
## GHC Core and performance tuning
- [Write Haskell as Fast as C](write_haskell_as_fast_as_c.md)
- [Grokking sum types, value constructors, and type constructors](http://bitemyapp.com/posts/2014-04-05-grokking-sums-and-constructors.html) squint hard.
- [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)
## Graph algorithms and data structures
- https://hackage.haskell.org/package/fgl particularly the shortest path algos here which are pure: http://hackage.haskell.org/package/fgl-5.4.2.2/docs/Data-Graph-Inductive-Query-SP.html
- The [fgl package](https://hackage.haskell.org/package/fgl) particularly the shortest path algos [here](http://hackage.haskell.org/package/fgl-5.4.2.2/docs/Data-Graph-Inductive-Query-SP.html) which are pure.
- [SO question about PHOAS](http://stackoverflow.com/questions/24369954/separate-positive-and-negative-occurrences-of-phoas-variables-in-presence-of-rec)
- https://www.fpcomplete.com/user/edwardk/phoas
- [PHOAS for free](https://www.fpcomplete.com/user/edwardk/phoas).
Sumit Sahrawat
9 years ago