Haskell Course
This course is designed to teach non-engineers (e.g., self-taught/bootcamp coders) Haskell from zero to productive in an interactive, easy-to-follow way. The course doesn't contain content specific to Marlowe or Plutus, but it will cover everything needed to work with them.
For a more detailed explanation, keep reading or watch the introduction video:
How much should I study if I only wish to use Marlowe/Plutus?
In the outline below, there are clear stopping points (for both Marlowe and Plutus) where we deem you to know enough Haskell to effectively use the technology.
How to read/watch the lessons
To go through the interactive lessons, go to your chosen lesson's outline inside "What we'll cover" and click on the button that looks like the one below. If the page loads with a "500: Internal Server Error" just refresh it, and it should be fine. At the top, you will see a console that displays the progress of preparing your interactive lesson. During this time, you can scroll down and look at the lesson, that is displayed non-interactively.
And to see the video lessons, click on the button that looks like this:
To do the homework
- Clone this repository.
- Create a GitPod account.
- Click this button to create a remote dev environment:
- Select the
Homework/HomeworkXX
folder with the homework you want to complete. - Follow the instructions inside the
Homework.hs
orMain.hs
file. - Check the solutions in the
solutions
branch!
Repository structure
Haskell-Course
| |
| |---- Homework
| |
| |---- Homework01 (Homework for lesson 01)
| |---- Homework02 (Homework for lesson 02)
| ...
|
|-------- lessons (Lessons in Jupyter notebook format. Access through Binder.)
|
|---- 1-Introduction-to-haskell
|---- 2-Functions-Data-Types-and-Signatures
Everything else can be safely ignored
To hang out and discuss with other students
FAQ
Proposed changes for next iteration/version
What we'll cover
This is a tentative outline. Changes can (and will) be made as we advance with the course and gather feedback from students.
If there are no buttons on a lesson, it means that it's not published yet.
BEGINNER SECTION - GETTING STARTED WITH HASKELL - 🥚⟶🐣
In this section, we get familiar with basic concepts and Haskell syntax.
- Intro to the course and lectures
- What we’ll cover
- Repository structure
- Intro to Haskell
- How to open and use JupyterLab
- Purely functional programming language
- Basic syntax
- Haskell Type system
- Laziness
- GHC (and GHCi)
- GitPod
- How to open and use GitPod
- Example of how to complete a homework assignment.
- Pragmatic intro to types
- Type signature
- Function’s signatures
- Variables in Haskell
- Parameters in functions
- Names/Definitions
- Infix and prefix functions
- Data Types in depth
- Int, Integer
- Float, Double
- Rational
- Bool
- Char
- Lists
- Strings
- Tuples + Tuples VS Lists
- Polymorphic values and type variables
- If-then-else
- Guards
let
expressionswhere
- Should I use
let
orwhere
? - Things to keep in mind
- What is pattern matching
- Pattern matching on
- Function implementations
- Lists
- Tuples
- Case
- Higher-order functions
- The
filter
function - The
any
function
- The
- Lambda functions
- Precedence and associativity
- Curried functions
- Partial application
- Composing and applying functions
- The
$
operator - The
.
operator
- The
- Point-free style
- Why Recursion?
- Thinking Recursively
sum
andproduct
- Steps to create your own recursive function
- Examples of recursion
and
,length
,reverse
,drop
,take
,map
,filter
- Extracting the
foldr
pattern - The
foldl
function - The
foldl'
function - When to use
foldr
,foldl
, andfoldl'
- The awesomeness of type classes
- What are type classes
- Common type classes
Eq
,Ord
Num
,Integral
,Floating
Read
,Show
- The most general valid type
- Multiple constraints
- Type synonyms
- How to define type synonyms
- Why use type synonyms
- Defining new types
- Creating new types with
data
- Using new types
- Value parameters
- Creating new types with
- Record syntax
- Type Parameters
- Prameteryzing
type
synonyms - Prameteryzing
data
types
- Prameteryzing
- Recursive data types
Tweet
me a river- A
Sequence
ofNode
s - A
Tree
ofNode
s
- Kinds
- The
newType
keyword
- Overloading
- Steps to create Type Classes and Instances
- The
Eq
type class- Defining the Type Class
- Defining multiple instances
- Improving our
Eq
type class with mutual recursion (and Minimal Complete Definitions) - Defining an instance for a parameterized type.
- The
WeAccept
Type Class - The
Container
Type Class - Exploring
Ord
type class (Subclassing) - Deriving
- Deriving can go wrong
- Pure functions
- Introduction to IO actions
- IO actions under the hood
- IO actions in practice
- The
()
type
- The
- Interacting with the user
getChar
,getLine
, andputStrLn
- Actions are first-class values
- Composing IO actions (
>>
and>>=
operators) - The
do
block- Using
let
, nesting do-blocks, escapingIO
andreturn
- Using
- The
main
action - Concepts and syntax recap
BEGINNER SECTION - GAINING INDEPENDENCE - 🐣⟶🐥
In this section, we learn about Haskell tooling and the necessary concepts to start working on our own projects.
- Installing Haskell
- Installing GHCup
- Installing GHC, Cabal, Stack, and HLS with GHCup
- Installing VSCode Extensions
- Creating our first program
- Writing the simplest Haskell program
- Compiling and running our program
- Importing Modules
- Controlling environments
- Controlling namespaces
- Creating our own Modules
- The Prelude and Standard Libraries
- Cabal
- Introduction to Cabal
- Creating a new Haskell project
- Going over the Cabal file using an external library
- Building and running our executable
- Language extensions and Pragmas
- Introduction
- NumericUnderscores
- TypeApplications
14. Handling Errors
- TODO
15. Learning on your own and Map
- Using GHCi to find out more
- Hoogle
- HaskellWiki
- Walking through while teaching Map module
Congratulations! 🥳 You can call yourself a (beginner) Haskell developer!
YOU'RE READY FOR THE MARLOWE PIONEER PROGRAM! 🥳🎉 (Keep going for Plutus.)
INTERMEDIATE SECTION - BASIC ABSTRACTIONS - 🐥⟶🐓
In this section, we learn about a few of the most useful and talked about Abstractions in Haskell.
x. Monoid
- Basic idea (definition without details)
- Intuitive examples
- Extracting the pattern
- Complete definition (with all the details/laws)
x. Functor
- Basic idea (definition without details)
- Intuitive examples
- Extracting the pattern
- Complete definition (with all the details/laws)
x. Applicative
- Basic idea (definition without details)
- Intuitive examples
- Extracting the pattern
- Complete definition (with all the details/laws)
x. Aeson
- TODO (some project using Aeson)
x. Monad
- Basic idea (definition without details)
- Intuitive examples
- Extracting the pattern
- Complete definition (with all the details/laws)
do
notation in general
x. Reader Monad
- Incentive/Motivation
- Binding strategy (see here)
- Definition
- Examples
x. Writer Monad
- Incentive/Motivation
- Binding strategy
- Definition
- Examples
x. State Monad
- Incentive/Motivation
- Binding strategy
- Definition
- Examples
x. Monadic functions / Operating with Monads
- liftM
- sequence and sequence_
- mapM and mapM_
- filterM
- foldM
TODO: It keeps going, but I'm not sure about the outline yet. 😬
Possible subjects:
- Testing
- TLP
- Template Haskell
- More abstractions
- Programming patterns