Chapter 1: Introduction to Haskell
- Lesson 1: What is Haskell?
- Lesson 2: History of Haskell and Functional Programming
- Lesson 3: Applications and Use Cases of Haskell
- Lesson 4: Setting Up the Haskell Environment (GHC, GHCi, Stack, Cabal)
- Lesson 5: Writing Your First Haskell Program
- Lesson 6: Introduction to Haskell Syntax and Basic Functions
Chapter 2: Variables, Data Types and Type System
- Lesson 1: Immutable Variables in Haskell
- Lesson 2: Primitive Data Types: Int, Integer, Float, Double, Char, Bool
- Lesson 3: Type Inference and Type Signatures
- Lesson 4: Strong Typing and Type Safety
- Lesson 5: Pattern Matching in Variable Definitions
- Lesson 6: Lazy Evaluation and Its Impact on Variables
Chapter 3: Operators and Expressions in Haskell
- Lesson 1: Arithmetic Operators
- Lesson 2: Relational and Comparison Operators
- Lesson 3: Logical Operators (&&, ||, not)
- Lesson 4: Function Application Operator ($)
- Lesson 5: Function Composition Operator (.)
- Lesson 6: Lambda Expressions and Anonymous Functions
- Lesson 7: Higher-Order Operators (map, fold, filter)
Chapter 4: Control Structures
- Lesson 1: Conditional Expressions (if-then-else)
- Lesson 2: Case Expressions and Pattern Matching
- Lesson 3: Guards in Haskell
- Lesson 4: Recursion vs. Looping (Haskell’s Loop Alternative)
- Lesson 5: List Comprehensions
Chapter 5: Functions and Functional Programming Concepts
- Lesson 1: Declaring and Using Functions
- Lesson 2: Function Application and Currying
- Lesson 3: Partial Application of Functions
- Lesson 4: Recursive Functions in Haskell
- Lesson 5: Higher-Order Functions
- Lesson 6: Anonymous and Lambda Functions
- Lesson 7: Combinators and Function Composition
Chapter 6: Lists, Tuples and Data Structures
- Lesson 1: Lists in Haskell
- Lesson 2: Common List Operations (head, tail, init, last, length, reverse)
- Lesson 3: Lazy Lists and Infinite Lists
- Lesson 4: Working with Tuples
- Lesson 5: List Comprehensions and Pattern Matching with Lists
- Lesson 6: Associative Lists (Dictionaries)
- Lesson 7: Arrays and Vectors in Haskell
Chapter 7: Type Classes and Polymorphism
- Lesson 1: Introduction to Type Classes
- Lesson 2: Built-in Type Classes: Eq, Ord, Show, Read, Enum, Num, Integral, Fractional
- Lesson 3: Creating Custom Type Classes
- Lesson 4: Deriving Type Classes Automatically
- Lesson 5: Parametric Polymorphism
- Lesson 6: Ad-hoc Polymorphism (Overloading)
Chapter 8: Algebraic Data Types (ADTs)
- Lesson 1: Defining Custom Data Types
- Lesson 2: Sum and Product Types
- Lesson 3: Recursive Data Types
- Lesson 4: Record Syntax for Data Types
- Lesson 5: Pattern Matching with ADTs
- Lesson 6: The Maybe and Either Types
Chapter 9: Monads and Functors in Haskell
- Lesson 1: Introduction to Functors
- Lesson 2: The Maybe Functor
- Lesson 3: Applicative Functors
- Lesson 4: Introduction to Monads
- Lesson 5: The IO Monad and Side Effects
- Lesson 6: Monad Laws and Monad Transformers
Chapter 10: Lazy Evaluation and Performance Optimization
- Lesson 1: Understanding Lazy Evaluation
- Lesson 2: Memoization and Caching
- Lesson 3: Strict vs. Lazy Evaluation
- Lesson 4: Using seq and deepseq for Performance
Chapter 11: Working with Input/Output (IO) in Haskell
- Lesson 1: Introduction to the IO Monad
- Lesson 2: File Handling in Haskell
- Lesson 3: Reading and Writing Files
- Lesson 4: Working with Command-Line Arguments
Chapter 1: Concurrency and Parallelism
- Lesson 1: Introduction to Concurrency in Haskell
- Lesson 2: The forkIO Function and Lightweight Threads
- Lesson 3: Using STM (Software Transactional Memory)
- Lesson 4: Asynchronous Exceptions and Handling Threads
Chapter 2: Error Handling and Exception Handling
- Lesson 1: Error Handling with Maybe and Either
- Lesson 2: Exception Handling Using Control.Exception
- Lesson 3: Custom Exception Types
Chapter 3: Working with Databases
- Lesson 1: Connecting to a Database
- Lesson 2: Using Persistent and Esqueleto Libraries
- Lesson 3: Writing Queries with Haskell
Chapter 4: Web Development with Haskell
- Lesson 1: Introduction to Yesod, Scotty, and Servant
- Lesson 2: REST API Development in Haskell
- Lesson 3: WebSockets in Haskell
Chapter 5: Creating and Deploying Haskell Libraries
- Lesson 1: Introduction to Haskell Package Management
- Lesson 2: Writing and Packaging a Haskell Library
- Lesson 3: Publishing a Package on Hackage
Chapter 6: Testing and Property-Based Testing
- Lesson 1: Introduction to Unit Testing in Haskell
- Lesson 2: Using QuickCheck for Property-Based Testing
Chapter 7: Cryptography and Security in Haskell
- Lesson 1: Basic Cryptographic Concepts
- Lesson 2: Implementing Hash Functions in Haskell
Chapter 8: Networking and Socket Programming
- Lesson 1: Basics of Networking in Haskell
- Lesson 2: Writing a Simple TCP Server
Chapter 9: Functional Reactive Programming (FRP) in Haskell
- Lesson 1: Introduction to FRP
- Lesson 2: Using Reflex and Reactive-Banana
Chapter 10: Design Patterns in Haskell
- Lesson 1: What are Design Patterns?
- Lesson 2: Creational Patterns | Singleton, Factory Method, Abstract Factory, Builder, Prototype
- Lesson 3: Structural Patterns | Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy
- Lesson 4: Behavioral Patterns | Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, Visitor
- Lesson 5: The Monad Pattern in Haskell
- Lesson 6: The Functor and Applicative Patterns in Haskell
Chapter 11: Meta-Programming and Template Haskell
- Lesson 1: Introduction to Template Haskell
- Lesson 2: Writing Compile-Time Metaprograms
Chapter 12: Signal Handling in Haskell
- Lesson 1: Introduction to Signal Handling in Haskell
- Lesson 2: POSIX Signals and Haskell
- Lesson 3: Using System.Posix.Signals Module
- Lesson 4: Handling Interrupts (SIGINT, SIGTERM, etc.)
- Lesson 5: Signal Handling in Concurrent Haskell
- Lesson 6: Graceful Shutdown of Haskell Applications
Chapter 13: Preprocessor Directives in Haskell
- Lesson 1: Introduction to Preprocessor Directives
- Lesson 2: Using CPP Extension in Haskell
- Lesson 3: #ifdef, #ifndef, #define, and #undef
- Lesson 4: Conditional Compilation in Haskell
- Lesson 5: Using Preprocessor Macros in Haskell Projects
- Lesson 6: Debugging with Preprocessor Directives
Chapter 14: GADTs (Generalized Algebraic Data Types) in Haskell
- Lesson 1: What are GADTs?
- Lesson 2: Syntax and Declaration of GADTs
- Lesson 3: Benefits of GADTs Over Regular ADTs
- Lesson 4: Type Safety and GADT Use Cases
- Lesson 5: Pattern Matching with GADTs
- Lesson 6: Advanced Use Cases of GADTs
Chapter 15: Type-Level Programming in Haskell
- Lesson 1: Introduction to Type-Level Programming
- Lesson 2: Type Families and Associated Types
- Lesson 3: Type-Level Computation
- Lesson 4: Dependent Types in Haskell
- Lesson 5: Kind System and Type-Level Constraints
- Lesson 6: Applications of Type-Level Programming
Chapter 16: Multi-parameter Type Classes
- Lesson 1: Introduction to Multi-parameter Type Classes
- Lesson 2: Syntax and Examples of Multi-parameter Type Classes
- Lesson 3: Functional Dependencies (FunctionalDependencies Extension)
- Lesson 4: Using TypeFamilies with Multi-parameter Type Classes
- Lesson 5: Resolving Type Ambiguities
- Lesson 6: Practical Applications of Multi-parameter Type Classes
Chapter 17: Category Theory Concepts in Haskell
- Lesson 1: Introduction to Category Theory
- Lesson 2: Functors and Natural Transformations
- Lesson 3: Monads and Their Category-Theoretic Meaning
- Lesson 4: Applicative Functors in Category Theory
- Lesson 5: Arrows and Compositional Structures
- Lesson 6: Monad Transformers and Their Category-Theoretic Interpretation