O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Learning Path: Haskell: Functional Programming and Haskell

Video Description

Leverage the power of functional programming

In Detail

Haskell is a powerful and well-designed functional programming language designed to work with complex data. Its emphasis on "purity" makes it easier to create rock-solid applications which stay maintainable and error-free even as they grow in scale.

In this learning path, we will cover the fundamentals and building blocks of Haskell with special emphasis on functional programming. You will learn how to solve problems while creating an application. You will then move on to learning how to write expressions and high-order functions.

We’ll also discover different ways to structure interactions between the program and the outside world.

We will then go on to discuss two other structured forms of interaction: streaming libraries and functional reactive programming.

By the end of this course, you’ll have an in-depth knowledge of various aspects of Haskell, allowing you to make the most of functional programming in Haskell.

Prerequisites: No prior knowledge on Haskell required.

Resources: Code downloads and errata:

  • Fundamentals of Practical Haskell Programming

  • Learning Haskell Programming

  • Mastering Haskell Programming

  • PATH PRODUCTS

    This path navigates across the following products (in sequential order):

  • Fundamentals of Practical Haskell Programming (2h 59m)

  • Learning Haskell Programming (4h 10m)

  • Mastering Haskell Programming (6h 04m)

  • Table of Contents

    1. Chapter 1 : Fundamentals of Practical Haskell Programming
      1. The Course Overview 00:04:10
      2. Installing Stack on Windows 00:07:43
      3. Installing Stack on Mac OS 00:06:33
      4. Installing Stack on Linux 00:05:24
      5. Problems FP and Haskell Can Address 00:06:30
      6. The FP Way 00:10:55
      7. The Haskell Way 00:09:08
      8. Our First Haskell Programs 00:15:42
      9. Whitespace, Layout, and Scoping 00:08:39
      10. GHCi and Interactive Haskell 00:08:56
      11. Debugging with GHCi 00:11:30
      12. Values and Expressions 00:24:39
      13. Types and Type Signatures 00:18:42
      14. Algebraic Data Types 00:11:46
      15. Type Classes 00:16:56
      16. Pattern Matching 00:12:28
    2. Chapter 2 : Learning Haskell Programming
      1. The Course Overview 00:02:59
      2. Installing Haskell 00:03:40
      3. Installation Instructions for OS X 00:04:45
      4. Installation Instructions for Windows 00:03:11
      5. Installation Instructions for Linux 00:05:33
      6. Discovering Haskell with ghci 00:13:03
      7. Built-in Data Structures 00:10:32
      8. Editing Haskell Source Code 00:06:25
      9. Introduction to Functions 00:10:07
      10. Building Your Own Data Structures 00:09:23
      11. Pattern Matching 00:09:28
      12. Creating a Project with Stack 00:11:51
      13. Setting up the Word Game Grid 00:08:26
      14. Searching for Words 00:19:39
      15. Searching in All Directions 00:14:02
      16. Unit Testing the Grid with Hspec 00:07:33
      17. Grid Coordinates and Infinite Lists 00:20:44
      18. Fleshing Out the Grid Model 00:23:38
      19. Searching the Grid Recursively 00:22:21
      20. Making the Game Playable 00:30:20
      21. Some Final Polish 00:12:24
    3. Chapter 3 : Mastering Haskell Programming
      1. The Course Overview 00:05:30
      2. Installation and Setup 00:04:40
      3. IO as a “Sin Bin” 00:14:28
      4. Exception Handling 00:09:25
      5. Fewer Sins Using the Free Monad 00:14:35
      6. Benign Side-Effects Using unsafePerformIO 00:06:34
      7. Simple Streaming Using Lazy IO 00:08:51
      8. Pure Streaming Using Lazy Lists 00:09:53
      9. Composing Finite and Infinite Streams 00:10:14
      10. Who's Driving? Push, Pull… or Both! 00:10:09
      11. Transforming Effectful Streams Using the Free Monad 00:08:09
      12. Events, Behaviors, and Signals 00:08:41
      13. Local and Global States 00:09:46
      14. Higher-Order Signals and Time Leaks 00:12:38
      15. Pure, Monadic, and Arrowized APIs 00:13:08
      16. Continuous, Synchronous, Total Time 00:12:20
      17. Parallel and Concurrent Algorithms 00:11:36
      18. Manual Parallelism Using the Free Applicative 00:11:07
      19. Laziness and Parallelism 00:08:59
      20. Purity and Parallelism 00:14:04
      21. Deterministic Communication Using IVars 00:13:23
      22. Deterministic Collaboration Using LVars 00:10:46
      23. Manual Concurrency Using forkIO 00:04:42
      24. Taming Asynchronous APIs Using ContT 00:12:10
      25. Opportunistic Concurrency Using Async 00:05:01
      26. Laziness and Concurrency 00:08:36
      27. Manual Signaling Using MVars 00:09:48
      28. Automatic Signaling Using TVars 00:12:50
      29. Effect Tracking and Concurrency 00:10:38
      30. Combinator Libraries 00:11:31
      31. Monad Transformers 00:10:37
      32. Nesting Architectures 00:09:16
      33. Precise Types, Program Boundaries, and Microservices 00:10:45
      34. Optimizing Microservice Requests Using Haxl 00:07:56
      35. Distributed Concurrent Programming Using Cloud Haskell 00:08:43
      36. CRDTs, Type Class Laws, and Eventual Consistency 00:12:54