Skip to content

This course is designed to teach students Haskell from zero to everything needed to work with Marlowe and Plutus. The course itself doesn't contain content specific to Marlowe or Plutus. So, if you want to use it to learn Haskell for other purposes, you can! πŸ˜ƒ

License

Notifications You must be signed in to change notification settings

BillyBadBoy/haskell-course

Β 
Β 

Repository files navigation

Haskell Course

VersiΓ³n en πŸ‡ͺπŸ‡Έ

This course is designed to teach students Haskell from zero to everything needed to work with Marlowe and Plutus. The course itself doesn't contain content specific to Marlowe or Plutus. So, if you want to use it to learn Haskell for other purposes, you can! πŸ˜ƒ

For a more detailed explanation, keep reading or watch the introduction video: YouTube

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.

Binder

And to see the video, click on the button that looks like this:

YouTube

To do the homework

  1. Clone this repository.
  2. Create a GitPod account.
  3. Click this button to create a remote dev environment: Visual Studio Code
  4. Select the Homework/HomeworkXX folder with the homework you want to complete.
  5. Follow the instructions inside the Homework.hs or Main.hs file.
  6. 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

FAQ

Proposed changes for next iteration/version

Changes

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.


START OF THE BEGINNER SECTION 🐣⟢πŸ₯


1. Intro and tools Binder YouTube

  • 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.

2. Data types, Signatures, and Polymorphism Binder YouTube

  • 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

3. Conditions and helper constructions Binder YouTube

  • If-then-else
  • Guards
  • let expressions
  • where
  • Should I use let or where?
  • Things to keep in mind

4. Pattern matching and Case Binder YouTube

  • What is pattern matching
  • Pattern matching on
    • Function implementations
    • Lists
    • Tuples
  • Case

5. Improving and combining functions Binder YouTube

  • Higher-order functions
    • The filter function
    • The any function
  • Lambda functions
  • Precedence and associativity
  • Curried functions
    • Partial application
  • Composing and applying functions
    • The $ operator
    • The . operator
  • Point-free style

6. Recursion Binder YouTube

  • Why Recursion?
  • Thinking Recursively
    • sum and product
  • 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, and foldl'

7. Intro to Type Classes Binder YouTube

  • 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

8. Creating Non-Parameterized Types Binder YouTube

  • Type synonyms
    • How to define type synonyms
    • Why use type synonyms
  • Defining new types
    • Creating new types with data
    • Using new types
    • Value parameters
  • Record syntax

9. Creating Parameterized and Recursive Types Binder YouTube

  • Type Parameters
    • Prameteryzing type synonyms
    • Prameteryzing data types
  • Recursive data types
    • Tweet me a river
    • A Sequence of Nodes
    • A Tree of Nodes
  • Kinds
  • The newType keyword

10. Creating Type Classes and Instances Binder YouTube

  • 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

11. Basic IO Binder YouTube

  • Pure functions
  • Introduction to IO actions
  • IO actions under the hood
  • IO actions in practice
    • The () type
  • Interacting with the user
    • getChar, getLine, and putStrLn
  • Actions are first-class values
  • Composing IO actions (>> and >>= operators)
  • The do block
    • Using let, nesting do-blocks, escaping IO and return
  • The main action
  • Concepts and syntax recap

12. Pragmas, Modules, and Cabal

  • Prelude
  • pragmas/extensions
  • Overview of base modules
  • Importing base modules
  • A few modules
    • Data.Char
    • Data.Tuple
    • Data.Array
  • Creating our own modules
  • Cabal
    • What is it and why we use it
    • Cabal file
    • Using external libraries with Cabal

13. Bits and Bytes

  • Grouping bits and bytes
  • Haskell and bytes
  • Lazy and strict byte strings
  • Example

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

END OF THE BEGINNER SECTION πŸ₯


Congratulations! πŸ₯³ You can call yourself a (beginner) Haskell programmer!

YOU'RE READY FOR THE MARLOWE PIONEER PROGRAM! πŸ₯³πŸŽ‰ (Keep going for Plutus.)


START OF THE INTERMEDIATE SECTION πŸ₯βŸΆπŸ“


16. Monoid

  • Basic idea (definition without details)
  • Intuitive examples
  • Extracting the pattern
  • Complete definition (with all the details/laws)

17. Functor

  • Basic idea (definition without details)
  • Intuitive examples
  • Extracting the pattern
  • Complete definition (with all the details/laws)

18. Applicative

  • Basic idea (definition without details)
  • Intuitive examples
  • Extracting the pattern
  • Complete definition (with all the details/laws)

19. Aeson

  • Aeson

20. Monad

  • Basic idea (definition without details)
  • Intuitive examples
  • Extracting the pattern
  • Complete definition (with all the details/laws)
  • do notation in general

21. Reader Monad

  • Incentive/Motivation
  • Binding strategy (see here)
  • Definition
  • Examples

22. Writer Monad

  • Incentive/Motivation
  • Binding strategy
  • Definition
  • Examples

23. State Monad

  • Incentive/Motivation
  • Binding strategy
  • Definition
  • Examples

24. 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. 😬

About

This course is designed to teach students Haskell from zero to everything needed to work with Marlowe and Plutus. The course itself doesn't contain content specific to Marlowe or Plutus. So, if you want to use it to learn Haskell for other purposes, you can! πŸ˜ƒ

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages

  • Jupyter Notebook 95.2%
  • Haskell 4.7%
  • Other 0.1%