Haskell

Hello, and welcome to the Haskell computer programming course.

Contributing
All contributions are appreciated. Even newcomers are welcome to make changes, remember Be bold !

If you're a prospective student, don't be shy; Haskell has a reputation for being difficult but hopefully we can convince you that this is mostly undeserved. Additionally we hope to show you the wonders of functional programming and the intersection of mathematics and programming. Finally, please let us know if you have trouble learning or understanding anything in this course.

If you're a prospective contributor, feel free to any topic you feel comfortable with. There's quite a bit of work to be done here. Feel free to make large changes if you need to; the structure of certain parts of this course haven't been as meticulously designed as they should be yet and may need to be changed significantly.

Scope and Purpose
This course will have multiple uses based on how far and which sections are covered by the student. Various lesson plans will be laid out.

This course is likely going to be an advanced course but will start from the basics and hopefully should be completely usable by any motivated student, regardless of prior programming or mathematical knowledge (assumptions of knowledge will be documented so that links to other courses can be provided).

This course focuses on developing strong mathematical foundations and intuitions that aspiring Haskell programmers will find valuable both while using Haskell and possibly in other contexts as well.

Haskell is in an interesting place because it is both very interesting from an academic/research perspective but also a powerful tool for rapidly producing high quality code (in terms of speed, safety, and extensibility). This course will attempt to give a strong foundation for the more theoretical aspects of Haskell, but will also provide projects and problems to assist students in becoming comfortable and productive with Haskell as a tool for solving problems.

Lessons for Beginners

 * /Introduction/


 * /Basic Haskell/
 * /Functions/
 * /Thinking with types/
 * /Higher-order functions/
 * Recursion, folding, and map-reducing
 * Laziness
 * Typeclasses
 * Functors
 * Applicative
 * Monads
 * Syntactic sugar

Intermediate Lessons

 * Language extensions
 * Foldable and traversable
 * Monad transformers
 * Parsing
 * Dealing with text properly
 * Comonads
 * Profunctors
 * Basic lenses
 * QuickCheck and testing
 * Arrows

Advanced Lessons

 * Quantification
 * More lenses
 * Generalized abstract data types
 * Type families
 * Foreign function interface
 * Concurrency and parallelism
 * Optimization
 * Core
 * Plated

Class Projects
Ideally class projects can be designed in such a way that students can:
 * 1) Do something novel
 * 2) Do something interesting
 * 3) Create it as they learn (build off of their previous work)
 * 4) Show mastery of various topics and ability to use Haskell as a productive tool

A few ideas for this are:
 * Making an interpreter
 * Making an emulator
 * Making a compiler
 * Making a website
 * Making a text editor
 * Making a video game