learnhaskell/README.md

556 lines
22 KiB
Markdown
Raw Normal View History

2014-05-19 19:43:44 +00:00
This is my recommended path for learning Haskell.
2014-05-19 19:43:26 +00:00
2014-05-19 19:43:44 +00:00
#### Something to keep in mind: *don't sweat the stuff you don't understand immediately*. Just keep moving.
2014-07-01 00:42:21 +00:00
# Community
Our IRC channel is `#haskell-beginners` on Freenode.
IRC web client here: http://webchat.freenode.net/
2014-08-04 05:49:49 +00:00
## Community Guidelines
2014-08-04 05:42:31 +00:00
[Letter to a Young Haskell Enthusiast](http://comonad.com/reader/2014/letter-to-a-young-haskell-enthusiast/)
2014-08-04 05:49:49 +00:00
Be nice above all else!
2014-05-19 19:43:44 +00:00
# Primary course
## 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/
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.
2014-05-19 19:43:44 +00:00
## Getting started
2014-07-29 04:01:52 +00:00
### Ubuntu
2014-05-19 19:43:44 +00:00
This PPA is excellent and is what I use on all my Linux dev and build machines: http://launchpad.net/~hvr/+archive/ghc
Specifically:
2014-06-04 07:56:59 +00:00
- `sudo apt-get update`
2014-08-09 20:27:16 +00:00
- **12.04 and below** -> `sudo apt-get install python-software-properties`
- **12.04 and above** -> `sudo apt-get install software-properties-common`
2014-05-19 21:07:22 +00:00
- `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`
2014-05-19 19:43:44 +00:00
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)
2014-05-19 19:43:44 +00:00
*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.
2014-06-23 20:19:35 +00:00
### Debian
#### GHC Repository for debian stable
2014-07-06 07:32:50 +00:00
If you use debian stable, it is easier to use this: http://deb.haskell.org/. After installing GHC:
- Get `cabal-install` source at https://www.haskell.org/cabal/download.html
- Run `bootstrap.sh`
- Run `cabal update && cabal install cabal cabal-install alex happy`
#### 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:
2014-06-23 20:19:35 +00:00
2014-09-17 20:57:23 +00:00
- `sudo sed -i s/jessie/trusty/g /etc/apt/sources.list.d/hvr-ghc-jessie.list`
2014-06-23 20:19:35 +00:00
2014-09-17 20:57:23 +00:00
For other Debian versions, just replace all occurences of "jessie" with your version name in the command above.
2014-06-23 20:19:35 +00:00
2014-09-17 20:57:23 +00:00
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:
```
deb http://ppa.launchpad.net/hvr/ghc/ubuntu jessie main
```
Replace "jessie" with "trusty" in this line.
2014-06-23 20:19:35 +00:00
#### 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.
2014-07-18 05:19:29 +00:00
### Fedora 20
2014-07-18 05:19:29 +00:00
To install Haskell 7.8x from the unofficial repo (Fedora 21+ will include it in the official one:
- Add https://copr.fedoraproject.org/coprs/petersen/ghc-7.8/repo/fedora-20/petersen-ghc-7.8-fedora-20.repo as petersen-ghc-7.8-fedora-20.repo
- `sudo yum install ghc`
2014-05-19 20:22:18 +00:00
### Arch Linux
2014-05-19 20:18:36 +00:00
To install Haskell from the official repos on Arch Linux, run
2014-05-19 20:18:36 +00:00
su -c "pacman -S cabal-install ghc happy alex haddock"
2014-05-19 20:18:36 +00:00
### Gentoo
On Gentoo, you can install the individual components of the Haskell Platform
through Portage. If you use `ACCEPT_KEYWORDS=arch` (as opposed to
`ACCEPT_KEYWORDS=~arch`), Portage will install ancient versions of the various
Haskell things. With that in mind, iff you use `ACCEPT_KEYWORDS=arch`, add the
following to `/etc/portage/package.keywords`, replacing `amd64` with your
architecture.
>=dev-haskell/cabal-install-1.18.0.3 ~amd64
>=dev-lang/ghc-7.8.3 ~amd64
Once that is done,
emerge --jobs --ask --verbose dev-lang/ghc dev-haskell/cabal-install dev-haskell/happy dev-haskell/alex
Gentoo keeps a "stable" (read: old) version of `cabal-install` in the Portage
tree, so you'll want to use `cabal-install` to install the more recent version.
cabal update
cabal install cabal-install
2014-05-25 08:20:59 +00:00
### Mac OS X
2014-09-30 17:15:36 +00:00
#### 10.9
2014-05-25 08:20:59 +00:00
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.
2014-05-31 03:34:54 +00:00
- http://ghcformacosx.github.io/
2014-05-25 08:20:59 +00:00
2014-09-30 17:15:36 +00:00
#### 10.6-10.8
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
2014-05-25 08:20:59 +00:00
### Windows and other Linux users
2014-05-19 19:43:44 +00:00
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.
2014-05-31 03:34:54 +00:00
- http://www.haskell.org/ghc/
2014-05-19 19:43:44 +00:00
#### Cabal
Cabal does project management and dependency resolution. It's how you'll install projects, typically into their own sandbox.
2014-05-31 03:34:54 +00:00
- https://www.haskell.org/cabal/download.html
2014-05-19 19:43:44 +00:00
#### Detailed manual install guide for Mac OS X
2014-05-31 03:34:54 +00:00
You don't need this if you use the .app, but if it doesn't work for you, try this with the binary distribution.
2014-05-19 19:43:44 +00:00
2014-05-31 03:34:54 +00:00
- http://www.davesquared.net/2014/05/platformless-haskell.html
2014-05-19 19:43:44 +00:00
2014-07-02 22:10:37 +00:00
---
## Yorgey course - *Do this first*, this is the primary way I recommend being introduced to Haskell.
2014-05-19 19:43:44 +00:00
2014-08-28 21:55:57 +00:00
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.
2014-05-19 19:43:44 +00:00
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 http://learnyouahaskell.com/ and transition to cis194.
Learn You A Haskell and http://book.realworldhaskell.org/ are recommended primarily as supplemental references for completing the cis194 course if you are not new to programming. RWH has some additional material that LYAH does not that is useful to people using Haskell in production as well.
2014-07-02 22:10:37 +00:00
---
2014-05-19 19:43:44 +00:00
## 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.
2014-05-31 03:34:54 +00:00
- http://www.scs.stanford.edu/14sp-cs240h/
2014-05-19 19:43:44 +00:00
## Exercises for practice (the NICTA course)
You should do Yorgey's course before attempting this: https://github.com/NICTA/course/
## Secondary material, references
[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 learning some common typeclasses
Useful for understanding `Functor`, `Applicative`, `Monad`, `Monoid` and other typeclasses in general but also some Hask-specific category theory:
- http://www.haskell.org/haskellwiki/Typeclassopedia
### Understanding basic Haskell error messages
- http://ics.p.lodz.pl/~stolarek/_media/pl:research:stolarek_understanding_basic_haskell_error_messages.pdf
2014-05-19 19:43:44 +00:00
## Development Environment
### Emacs
- https://github.com/serras/emacs-haskell-tutorial/blob/master/tutorial.md
2014-06-10 18:43:20 +00:00
- https://github.com/bitemyapp/dotfiles/
2014-05-19 19:43:44 +00:00
### Vim
2014-05-31 03:34:54 +00:00
- http://www.haskell.org/haskellwiki/Vim
2014-05-19 19:43:44 +00:00
2014-05-31 03:34:54 +00:00
- http://www.stephendiehl.com/posts/vim_haskell.html
2014-05-19 19:43:44 +00:00
2014-05-31 03:34:54 +00:00
- https://github.com/kazu-yamamoto/ghc-mod
2014-05-19 19:43:44 +00:00
2014-05-31 03:34:54 +00:00
- https://github.com/eagletmt/ghcmod-vim
2014-05-19 19:43:44 +00:00
### Sublime Text
2014-05-31 03:34:54 +00:00
- https://github.com/SublimeHaskell/SublimeHaskell
2014-05-19 19:43:44 +00:00
## FAQ and working with Cabal
### Fantastic FAQ
2014-05-31 03:34:54 +00:00
In addition to being an amazing guide for all kinds of things such as GADTs, this also covers some useful basics for Cabal
- http://dev.stephendiehl.com/hask/
2014-05-19 19:43:44 +00:00
### Cabal guidelines
- http://softwaresimply.blogspot.com/2014/07/haskell-best-practices-for-avoiding.html
2014-06-13 02:27:37 +00:00
2014-05-19 19:43:44 +00:00
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.
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
- Use `cabal repl` to start a project-scoped ghci instance
2014-06-06 21:34:00 +00:00
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.
2014-05-19 19:43:44 +00:00
## Search code by type signature
The Hoogle search engine can search by type:
http://www.haskell.org/hoogle/?hoogle=%28a+-%3E+b%29+-%3E+%5ba%5d+-%3E+%5bb%5d
Alternately:
https://www.fpcomplete.com/hoogle
Also Hayoo (which has all of hackage enabled for search by default): http://holumbus.fh-wedel.de/hayoo/hayoo.html
### Setting up your own local instance of Hoogle
https://gist.github.com/bitemyapp/3e6a015760775e0679bf
2014-08-30 03:15:26 +00:00
## Haddock
- First: http://fuuzetsu.co.uk/blog/posts/2014-01-06-Fix-your-Hackage-documentation.html
- Second: http://fuuzetsu.co.uk/blog/posts/2014-01-06-Hackage-documentation-v2.html
### 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.
The other thing to keep in mind is that due to the way the $pkg parameter gets interpolated *by* haddock, 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
#!/bin/bash
cabal haddock --hoogle --hyperlink-source --html-location='http://hackage.haskell.org/package/$pkg/docs' --contents-location='http://hackage.haskell.org/package/$pkg'
```
2014-05-19 19:43:44 +00:00
## 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.
Seen here: http://hackage.haskell.org/package/lens
## Frontend/JavaScript
2014-05-19 19:47:45 +00:00
If you need JavaScript, you probably want Purescript for generating JS. Purescript is *not* strictly Haskell but it is very similar and quite pleasant.
2014-05-19 19:43:44 +00:00
- http://www.purescript.org/
2014-06-26 18:21:23 +00:00
2014-05-19 19:43:44 +00:00
- http://try.purescript.org/
2014-06-26 18:21:23 +00:00
- http://www.christopherbiscardi.com/2014/06/22/getting-started-with-purescript/ Great guide for getting started
2014-10-04 20:25:06 +00:00
## Parsing in Haskell
2014-10-04 20:56:57 +00:00
- Parser combinator tutorial for Haskell using Parsec: https://github.com/JakeWheat/intro_to_parsing
2014-10-04 20:25:06 +00:00
- Writing your own micro-Parsec: http://olenhad.me/articles/monadic-parsers/
2014-10-04 20:56:57 +00:00
2014-10-04 20:25:06 +00:00
### Parsing and generating JSON
2014-07-25 17:46:54 +00:00
- http://blog.raynes.me/blog/2012/11/27/easy-json-parsing-in-haskell-with-aeson/
- http://bitemyapp.com/posts/2014-04-11-aeson-and-user-created-types.html
- http://bitemyapp.com/posts/2014-04-17-parsing-nondeterministic-data-with-aeson-and-sum-types.html
- https://www.fpcomplete.com/school/starting-with-haskell/libraries-and-frameworks/text-manipulation/json
## Laziness, strictness, guarded recursion
2014-06-21 17:44:08 +00:00
- 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.
2014-06-09 21:04:35 +00:00
2014-06-21 17:44:08 +00:00
- http://augustss.blogspot.hu/2011/05/more-points-for-lazy-evaluation-in.html
2014-06-21 17:44:08 +00:00
- http://alpmestan.com/2013/10/02/oh-my-laziness/
2014-06-21 17:44:08 +00:00
- http://stackoverflow.com/questions/13042353/does-haskell-have-tail-recursive-optimization
- http://www.slideshare.net/tibbe/reasoning-about-laziness
2014-06-09 21:04:35 +00:00
2014-07-13 22:44:18 +00:00
### For a more thorough understanding of laziness, NF, WHNF
- https://vec.io/posts/notes-on-lambda-calculus
- http://homepages.inf.ed.ac.uk/wadler/topics/call-by-need.html#need-journal
- http://www.itu.dk/~sestoft/papers/sestoft-lamreduce.pdf
- http://www.cs.ox.ac.uk/files/293/lazy.pdf
### Brief demonstration
```haskell
let a = 1 : a -- guarded recursion, (:) is lazy and can be pattern matched.
2014-06-05 22:42:40 +00:00
let (v : _) = a
> v
1
> head a -- head a == v
1
let a = 1 * a -- not guarded, (*) is strict
> a
*** Exception: <<loop>>
```
2014-06-21 17:44:08 +00:00
- http://www.vex.net/~trebla/haskell/lazy.xhtml
2014-06-09 21:04:35 +00:00
2014-05-19 19:43:44 +00:00
## 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:
2014-05-19 19:43:44 +00:00
2014-05-31 03:34:54 +00:00
- 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
2014-05-31 03:34:54 +00:00
- http://www.haskell.org/haskellwiki/Functional_Reactive_Programming
2014-05-19 19:43:44 +00:00
## Lenses and Prisms
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.
2014-05-19 19:47:45 +00:00
If you've ever done something like: `(fmap . fmap)` you were "lensing" in your head.
2014-05-19 19:43:44 +00:00
I recommend these two tutorials/introductions:
2014-05-31 03:34:54 +00:00
- https://www.fpcomplete.com/school/to-infinity-and-beyond/pick-of-the-week/a-little-lens-starter-tutorial
2014-05-19 19:43:44 +00:00
2014-05-31 03:34:54 +00:00
- https://github.com/ekmett/lens#lens-lenses-folds-and-traversals
2014-05-19 19:43:44 +00:00
2014-08-20 22:34:30 +00:00
## Monads and monad transformers
2014-06-30 22:47:01 +00:00
### 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.
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
2014-06-30 22:47:01 +00:00
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.
From:
2014-06-30 22:47:01 +00:00
- http://www.reddit.com/r/haskell/comments/29eke6/basic_program_ideas_for_learning_about_monads/cik5aj6
- http://www.reddit.com/r/haskell/comments/29eke6/basic_program_ideas_for_learning_about_monads/cik5trg
2014-07-17 20:37:46 +00:00
### Monad transformers
- https://github.com/kqr/gists/blob/master/articles/gentle-introduction-monad-transformers.md
2014-10-11 22:45:20 +00:00
- http://www.cs.virginia.edu/~wh5a/personal/Transformers.pdf (warning, code out of date)
2014-07-17 20:37:46 +00:00
2014-10-16 20:00:51 +00:00
## Testing, tests, specs, generative/property testing
- https://github.com/kazu-yamamoto/unit-test-example/blob/master/markdown/en/tutorial.md This tutorial by Kazu Yamamoto is fantastic.
## Resource handling, finalization, cleanup
- Overview of resourceT by Snoyman: https://www.fpcomplete.com/user/snoyberg/library-documentation/resourcet
## Streaming IO
- 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
2014-07-25 17:46:54 +00:00
## 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.
This material dovetails with traversable and foldable.
- http://patrickthomson.ghost.io/an-introduction-to-recursion-schemes/
- http://fho.f12n.de/posts/2014-05-07-dont-fear-the-cat.html - good demonstration of how hylomorphism is the composition of cata and ana.
- http://comonad.com/reader/2009/recursion-schemes/ - this field guide is excellent.
- http://eprints.eemcs.utwente.nl/7281/01/db-utwente-40501F46.pdf
- https://www.fpcomplete.com/user/edwardk/recursion-schemes/catamorphisms
2014-05-19 19:43:44 +00:00
## Type and Category Theory (*not* needed to actually write Haskell, just for those interested!)
If you want to follow up on the type and category theory:
2014-06-23 23:38:56 +00:00
- http://byorgey.wordpress.com/2014/01/14/catsters-guide/ and http://byorgey.wordpress.com/catsters-guide-2/
2014-06-23 23:38:26 +00:00
2014-05-31 03:34:54 +00:00
- 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.
2014-05-19 19:43:44 +00:00
- http://www.quora.com/Category-Theory/What-is-the-best-textbook-for-Category-theory?share=1 Kmett's recommendations
2014-05-31 03:34:54 +00:00
- http://en.wikibooks.org/wiki/Haskell/Category_theory nice diagrams
2014-05-19 19:43:44 +00:00
2014-05-31 03:34:54 +00:00
- http://www.haskell.org/haskellwiki/Category_theory good links to other resources
2014-05-19 19:43:44 +00:00
2014-05-31 03:34:54 +00:00
- http://science.raphael.poss.name/categories-from-scratch.html includes practical examples
2014-05-25 12:09:02 +00:00
2014-05-31 03:34:54 +00:00
- https://www.google.com/search?q=Awodey+Category+Theory the standard text along with MacLane
2014-05-19 19:43:44 +00:00
2014-05-31 03:34:54 +00:00
- http://www.cs.kent.ac.uk/people/staff/sjt/TTFP/
2014-05-19 19:43:44 +00:00
2014-06-03 11:24:43 +00:00
- http://www.cis.upenn.edu/~bcpierce/courses/670Fall04/GreatWorksInPL.shtml Pierce's Great Works in PL list
### Stephen's Nifty "How to get to monad" posts
Didn't know where else to put these:
- http://www.stephendiehl.com/posts/adjunctions.html
- http://www.stephendiehl.com/posts/monads.html
2014-06-20 15:29:04 +00:00
## Parametricity, ad-hoc vs. parametric polymorphism, free theorems
- http://dl.dropboxusercontent.com/u/7810909/media/doc/parametricity.pdf
- https://github.com/tonymorris/parametricity/
2014-05-19 19:43:44 +00:00
2014-05-31 03:34:54 +00:00
- http://swizec.com/blog/week-20-making-ad-hoc-polymorphism-less-ad-hoc/swizec/6564
2014-05-19 19:43:44 +00:00
2014-05-31 03:34:54 +00:00
- http://ttic.uchicago.edu/~dreyer/course/papers/wadler.pdf
2014-05-19 19:43:44 +00:00
2014-06-04 20:34:47 +00:00
## Initial and Final, DSLs, Finally Tagless
2014-07-20 05:38:21 +00:00
- http://creativelad.wordpress.com/2013/11/28/final-encodings-part-1-a-quick-demonstration/
2014-06-04 20:34:47 +00:00
- http://martijn.van.steenbergen.nl/journal/2009/10/18/transforming-polymorphic-values/
- http://martijn.van.steenbergen.nl/journal/2009/11/12/gadts-in-haskell-98/
- https://www.fpcomplete.com/user/mutjida/typed-tagless-final-linear-lambda-calculus
- http://okmij.org/ftp/tagless-final/course/course.html
- http://okmij.org/ftp/tagless-final/course/lecture.pdf
- http://existentialtype.wordpress.com/2011/03/21/the-dog-that-didnt-bark/ less specifically relevant but interesting
2014-06-03 11:24:43 +00:00
## Comonads
- https://speakerdeck.com/dmoverton/comonads-in-haskell
2014-06-03 11:27:42 +00:00
- http://stackoverflow.com/questions/16551734/can-a-monad-be-a-comonad
2014-06-03 11:24:43 +00:00
## Yoneda / CoYoneda
- http://stackoverflow.com/questions/24000465/step-by-step-deep-explain-the-power-of-coyoneda-preferably-in-scala-throu
2014-08-25 19:41:47 +00:00
- http://comonad.com/reader/2011/free-monads-for-less/
- http://comonad.com/reader/2011/free-monads-for-less-2/
- http://comonad.com/reader/2011/free-monads-for-less-3/
## IO
- https://www.fpcomplete.com/user/snoyberg/general-haskell/advanced/evaluation-order-and-state-tokens
Comment from Reddit thread by `glaebhoerl`
2014-08-25 19:42:08 +00:00
2014-08-25 19:41:47 +00:00
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.
2014-08-25 19:42:08 +00:00
2014-08-25 21:37:16 +00:00
- http://blog.ezyang.com/2011/05/unraveling-the-mystery-of-the-io-monad/
2014-08-25 19:41:47 +00:00
- 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
2014-07-23 19:54:01 +00:00
## GHC Core and performance tuning
2014-07-23 20:35:12 +00:00
- [Write Haskell as Fast as C](write_haskell_as_fast_as_c.md)
2014-07-23 19:54:01 +00:00
- https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/CoreSynType
- https://hackage.haskell.org/package/ghc-core
- http://stackoverflow.com/questions/6121146/reading-ghc-core
- http://donsbot.wordpress.com/2008/06/04/haskell-as-fast-as-c-working-at-a-high-altitude-for-low-level-performance/
- http://book.realworldhaskell.org/read/profiling-and-optimization.html
2014-06-03 11:24:43 +00:00
## Dependent typing
- http://bitemyapp.com/posts/2014-04-05-grokking-sums-and-constructors.html squint hard.
- http://okmij.org/ftp/Computation/lightweight-dependent-typing.html
- http://www.idris-lang.org/
2014-06-26 20:48:47 +00:00
## Propositions vs. Judgments (computation)
- http://cstheory.stackexchange.com/questions/9826/what-is-the-difference-between-propositions-and-judgments
- http://www.ae-info.org/attach/User/Martin-L%C3%B6f_Per/OtherInformation/article.pdf
2014-09-22 03:43:11 +00:00
## 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
- http://web.engr.oregonstate.edu/~erwig/papers/abstracts.html#JFP01
- http://web.engr.oregonstate.edu/~erwig/fgl/haskell/old/fgl0103.pdf
- http://hackage.haskell.org/package/containers-0.5.5.1/docs/Data-Graph.html
- https://hackage.haskell.org/package/graphs
- http://stackoverflow.com/questions/24369954/separate-positive-and-negative-occurrences-of-phoas-variables-in-presence-of-rec
- https://www.fpcomplete.com/user/edwardk/phoas
- http://www.haskell.org/haskellwiki/Tying_the_Knot
2014-05-19 19:43:44 +00:00
## Extended Reading list (some is already included here)
2014-05-31 03:34:54 +00:00
- http://www.stephendiehl.com/posts/essential_haskell.html
2014-07-29 04:06:27 +00:00
2014-10-07 19:09:48 +00:00
## Stackage
For any users (usually Yesod users) that have build problems, consider Stackage.
- A good summary of Stackage is here: https://www.fpcomplete.com/blog/2014/05/stackage-server
In the author's opinion, Stackage is usually more useful than `cabal freeze`.
2014-07-29 04:06:27 +00:00
## Dialogues
[Dialogues](dialogues.md) these are actually pretty important and
helpful. Look here for deep dives on a variety of topics.