Master Haskell from Scratch- A Basic to Advanced Course

Name: Master Haskell from Scratch- A Basic to Advanced Course
Rating: 3.7 (2 reviews)

Get expertise of programming in Haskell

Created byAnurag Kaushik

Last updated 7/2025

English

English [Auto],

What you'll learn

Haskell
Haskell vs Python
Haskell Modules
Zippers in Haskell
Monads and Functor in Haskell

Course content

4 sections • 33 lectures • 6h 9m total length

Introduction to the Course2:29
Explore Haskell, a static language with an expressive type system and non-strict evaluation, and practice problem solving through types, polymorphism, type signatures, type classes, word game project, and ghci.
Problems FP and Haskell can Address5:36
Explore how functional programming and programming languages address reliability, tractability, and composability, and how Haskell offers a new perspective for building robust, concurrent and parallel software.
Installing Haskell on Linux3:01
Install Haskell on Ubuntu Linux using stack to obtain the Haskell toolchain. Configure stack, install GHC, and run simple expressions with stack GHC.
Functional Programming9:45
Explore functional programming fundamentals, comparing PHP to imperative paradigms, and learn pure functions, referential transparency, and higher-order functions using map, fold, filter, and composition.
Introduction to Haskell2:53
Explore Haskell, a purely functional language designed for symbolic computation and list processing, highlighting laziness, modularity, static typing, and its support for concurrency.
Haskell vs Python4:41
Compare Haskell and Python on functional versus procedural paradigms, static versus dynamic typing, and features like parametric and ad hoc polymorphism, type classes, speed, and libraries.
Basic Data Models9:42
Explore basic data models in Haskell, including numbers, characters, strings, booleans, lists and tuples, and learn list comprehension and immutability concepts.
First Haskell Programs15:47
Explore your first Haskell programs with hello world, ghci interactions, and do notation, while examining types, semantics, and essential tools like stack, ghc, and the prelude.
Whitespace Layout and Scoping9:42
Explore whitespace, braces, and lexical scoping in Haskell, and learn how indentation and layout influence let bindings, case expressions, and top-level names.

GHCi and Interactive Haskell12:25
Explore ghci, the interactive haskell read-evaluate-print loop, start it with stack, load programs, and prototype code using colon commands like :load, :type, and :info to inspect values and types.
Basic Operators6:33
Explore basic Haskell operators, including addition, subtraction, multiplication, and division, plus the range operator for lists like 1..10 and A..Z, with practical examples.
Decision Making4:59
Explore decision making in haskell by using if-else and nested if-else to control code flow based on a condition, with examples that output whether a number is even or odd.
Types and Type Class17:37
Explore types and type classes in Haskell, a typed functional language. Learn types like int, integer, float, double, bool, and char, and type classes such as eq, ord, show, read.
Haskell Functions15:01
Explore Haskell functions—from declaration and definition to pattern matching, guards, and recursion—along with where clause, higher-order functions, and lambda expressions, illustrated by add, factorial, roots, and map.
More on Functions13:08
Learn about common Haskell list functions such as head, tail, last, init, null, reverse, length, take, drop, maximum, minimum, sum, product, and lm for membership.
Function Composition3:32
Master Haskell from scratch explains function composition with the dot operator, chaining even number and no two to show output flowing from one function to the next.
Haskell Modules14:17
Explore how Haskell modules organize code and how to import them. Use list, map, and set modules and features like hiding and as clauses to manage scope.
Haskell Input and Output6:09
Learn dynamic input and output in Haskell by reading and writing external files with readFile and writeFile, and catch runtime errors using try and control.exception.
Functor in Haskell8:50
Explore Haskell functor, its mapping over types and polymorphism, with instances like list and map. Compare map and f map, then introduce applicative functor with pure and applied over, monoids.
Monads in Haskell3:21
Master monads in Haskell by studying monads as a type of applicative functor with extra features, and mastering the three laws: left identity, right identity, and associativity.
Zippers in Haskell4:22
Explore zippers in Haskell, a technique to update a specific position in a data structure without full traversal, demonstrated on a list with forward and back navigation.
Debugging with GHCi10:12
Explore debugging with ghci by customizing the ghci.conf startup, loading modules, and setting breakpoints; inspect thunks and force evaluation to understand non-strict evaluation and runtime behavior.

Creating a New Stack Project13:18
Create a new Haskell stack project for a word game, configure metadata, organize libraries and tests, and build, run, and test with stack ghci, stack build, and stack test.
Setting up the Word Game Grid7:23
Learn to set up and display a Haskell word game grid by declaring the grid and language list, formatting lines with unlines, and exporting display functions.
Searching of the Words in the Grid19:21
Search a grid for words using is infix of, map, and reverse to check left to right and right to left, then use maybe and cat maybes to return languages.
Searching in All Directions12:22
Explore searching a character grid in all directions—left-to-right, top-to-bottom, and diagonals—by applying reverse, transpose, and a recursive skew to build lines.
Unit Testing the Grid with Hspecs10:07
Learn to unit test a Haskell grid with Hspec, refactor data into a library, and validate format grid, find word, and find words with stack test.

Grid Coordinates and Infinite Lists24:39
Explore grid coordinates and infinite lists to build two-dimensional grids with list comprehensions, repeat, and zip. Generate coordinate grids and pair coordinates with grid values using zip over grid.
Fleshing Out the Grid Module21:06
Explore fleshing out the grid module in Haskell by introducing a parameterized grid and a cell type. Learn to zip over grid with and grid with, map cell to car.
Searching the Grid Recursively21:36
Master recursive grid search in Haskell by building a prefix and infix search on a coordinate grid, using an accumulator, maybe, and list processing taught with GHCi and Stack tests.
Making the Game Playable33:27
Build a playable word game in Haskell by modeling the game with a grid and a dictionary map, using the IO monad for input/output and turn-based play.
Some Random Polish16:03
Polish a Haskell word game by using system.random to generate a random grid, manage the IO monad generator, and highlight found words through grid formatting.
Command Line Arguments6:27
Learn to read command line arguments in Haskell by importing system.environment and data.list, accessing getArgs and getProgName, and printing the arguments and program name via GHCi.

Requirements

Basics of Programming
Basics of Functional Programming Language

Description

This course is about Haskell. Haskell is a strong, statically typed language with a very expressive type system. It also has non- strict evaluation, and it has a very unique approach to problem-solving. This course is going to emphasize using Haskell for practical problem-solving.

This course consists of several topics, in three sections. In the first topic, we'll talk about problems that FP and Haskell can address. Then we'll talk about the functional programming-specific ways of approaching these problems.

Then we'll talk about how Haskell specifically addresses these types of problems. Then we'll take a look at our first Haskell programs and start to begin an intuition for what they look like. And we'll dig deeper into some issues related to whitespace and layout.

Then we'll use the Glasgow Haskell Compiler's read-evaluate-print loop, known as GHCi, to explore our Haskell programs' values and types and expressions.

Then we'll learn to debug with GHCi. Moving on, we'll dig deeper, and we'll start to look at Haskell values and expressions, and specifically functions as values. We'll build an intuition for some of the core concepts.

Then we'll look at types, polymorphism constraints, and how we can add type signatures to our values. And we're looking to sum up product types in Haskell's record syntax. At that point, we'll know enough to tackle type classes, and we'll learn how to make our own instances of existing type classes and how to build our own type classes. Finally, to cap it all off, we'll learn how to extract values from our algebraic data types. At the end of this course, you will have a practical working knowledge of Haskell, enough to start writing your own program.

You'll also know how Haskell can help us solve problems in its particular approach to software engineering. And then, you'll also have knowledge of values, expressions and types in Haskell.

Who this course is for:

Students
Programmers
Learners

Master Haskell from Scratch- A Basic to Advanced Course

What you'll learn

Explore related topics

Course content

Module 19 lectures • 1hr 4min

Module 213 lectures • 2hr

Module 35 lectures • 1hr 3min

Module 46 lectures • 2hr 3min

Requirements

Description

Who this course is for: