Mastering Haskell Programming

Tracking Side-Effects Using IO 7 lectures 01:04:01 The Course Overview This video gives an overview of the entire course. Installation and Setup In this video, we will install everything you will need in order to follow along with the code I'll be presenting during the course.

• Install Stack, which in turn installs the Glasgow Haskell Compiler and all the libraries you will need in order to execute the code from my slides
• Fetch the slides using git and navigate them using git commands
• (optional) Install git-slides to navigate the slides more easily

IO as a "Sin Bin" In this video, we will look at the wide variety of side-effects supported by the IO monad.

• Call C functions from IO, this is where most of the side-effects come from
• Mutate single-cells and arrays from IO
• Create pointers with various semantics supported by the language runtime

Exception Handling In this video, you will learn the subtleties of exception handling in Haskell, including why throwing exceptions is one of the only side-effect which isn't tracked by Haskell's type system.

• A brief overview of the IO half of the exception handling API
• Learn how to guard resources in the presence of exceptions
• The other half: throwing exceptions from pure code

Fewer Sins Using the Free Monad In this video, we will try to understand why so many different kinds of side-effects live in the IO monad, as opposed to a more fine-grained system with multiple monads each responsible for tracking one effect. Then, we will create our own fine-grained effect-tracking monads.

• A simple module-based implementation of an effect-tracking monad
• A list-based implementation which simplifies testing
• Use a free monad to allow our implementation to support more complex computations

Benign Side-Effects Using unsafePerformIO In this video, you will learn how and when to use unsafePerformIO to execute side-effects within pure code.

• UseunsafePerformIO to inspect when and whether pure code is executed
• UseunsafePerformIO to define global variables
• Learn how unsafePerformIO can accidentally create bugs which are difficult to understand

Simple Streaming Using Lazy IO In this video, we will examine how lazy IO is implemented, and how the same underlying mechanism can be used to express effectful stream transformations.

• Introducing unsafeInterleaveIO by contrasting it with unsafePerformIO
• Introducing lazy IO by contrasting it with ordinary, strict IO
• Introducing effectful stream transformations by contrasting them with pure stream transformations

Tracking Side-Effects Using IO. 7 lectures 01:04:01 The Course Overview This video gives an overview of the entire course. Installation and Setup In this video, we will install everything you will need in order to follow along with the code I'll be presenting during the course.

• Install Stack, which in turn installs the Glasgow Haskell Compiler and all the libraries you will need in order to execute the code from my slides
• Fetch the slides using git and navigate them using git commands
• (optional) Install git-slides to navigate the slides more easily

IO as a "Sin Bin" In this video, we will look at the wide variety of side-effects supported by the IO monad.

• Call C functions from IO, this is where most of the side-effects come from
• Mutate single-cells and arrays from IO
• Create pointers with various semantics supported by the language runtime

Exception Handling In this video, you will learn the subtleties of exception handling in Haskell, including why throwing exceptions is one of the only side-effect which isn't tracked by Haskell's type system.

• A brief overview of the IO half of the exception handling API
• Learn how to guard resources in the presence of exceptions
• The other half: throwing exceptions from pure code

Fewer Sins Using the Free Monad In this video, we will try to understand why so many different kinds of side-effects live in the IO monad, as opposed to a more fine-grained system with multiple monads each responsible for tracking one effect. Then, we will create our own fine-grained effect-tracking monads.

• A simple module-based implementation of an effect-tracking monad
• A list-based implementation which simplifies testing
• Use a free monad to allow our implementation to support more complex computations

Benign Side-Effects Using unsafePerformIO In this video, you will learn how and when to use unsafePerformIO to execute side-effects within pure code.

• UseunsafePerformIO to inspect when and whether pure code is executed
• UseunsafePerformIO to define global variables
• Learn how unsafePerformIO can accidentally create bugs which are difficult to understand

Simple Streaming Using Lazy IO In this video, we will examine how lazy IO is implemented, and how the same underlying mechanism can be used to express effectful stream transformations.

• Introducing unsafeInterleaveIO by contrasting it with unsafePerformIO
• Introducing lazy IO by contrasting it with ordinary, strict IO
• Introducing effectful stream transformations by contrasting them with pure stream transformations

The Course Overview This video gives an overview of the entire course. The Course Overview This video gives an overview of the entire course. The Course Overview This video gives an overview of the entire course. The Course Overview This video gives an overview of the entire course. This video gives an overview of the entire course. This video gives an overview of the entire course. Installation and Setup In this video, we will install everything you will need in order to follow along with the code I'll be presenting during the course.

• Install Stack, which in turn installs the Glasgow Haskell Compiler and all the libraries you will need in order to execute the code from my slides
• Fetch the slides using git and navigate them using git commands
• (optional) Install git-slides to navigate the slides more easily

Installation and Setup In this video, we will install everything you will need in order to follow along with the code I'll be presenting during the course.

• Install Stack, which in turn installs the Glasgow Haskell Compiler and all the libraries you will need in order to execute the code from my slides
• Fetch the slides using git and navigate them using git commands
• (optional) Install git-slides to navigate the slides more easily

Installation and Setup In this video, we will install everything you will need in order to follow along with the code I'll be presenting during the course.

• Install Stack, which in turn installs the Glasgow Haskell Compiler and all the libraries you will need in order to execute the code from my slides
• Fetch the slides using git and navigate them using git commands
• (optional) Install git-slides to navigate the slides more easily

Installation and Setup In this video, we will install everything you will need in order to follow along with the code I'll be presenting during the course.

• Install Stack, which in turn installs the Glasgow Haskell Compiler and all the libraries you will need in order to execute the code from my slides
• Fetch the slides using git and navigate them using git commands
• (optional) Install git-slides to navigate the slides more easily

In this video, we will install everything you will need in order to follow along with the code I'll be presenting during the course.

• Install Stack, which in turn installs the Glasgow Haskell Compiler and all the libraries you will need in order to execute the code from my slides
• Fetch the slides using git and navigate them using git commands
• (optional) Install git-slides to navigate the slides more easily

In this video, we will install everything you will need in order to follow along with the code I'll be presenting during the course.

• Install Stack, which in turn installs the Glasgow Haskell Compiler and all the libraries you will need in order to execute the code from my slides
• Fetch the slides using git and navigate them using git commands
• (optional) Install git-slides to navigate the slides more easily

IO as a "Sin Bin" In this video, we will look at the wide variety of side-effects supported by the IO monad.

• Call C functions from IO, this is where most of the side-effects come from
• Mutate single-cells and arrays from IO
• Create pointers with various semantics supported by the language runtime

IO as a "Sin Bin" In this video, we will look at the wide variety of side-effects supported by the IO monad.

• Call C functions from IO, this is where most of the side-effects come from
• Mutate single-cells and arrays from IO
• Create pointers with various semantics supported by the language runtime

IO as a "Sin Bin" In this video, we will look at the wide variety of side-effects supported by the IO monad.

• Call C functions from IO, this is where most of the side-effects come from
• Mutate single-cells and arrays from IO
• Create pointers with various semantics supported by the language runtime

IO as a "Sin Bin" In this video, we will look at the wide variety of side-effects supported by the IO monad.

• Call C functions from IO, this is where most of the side-effects come from
• Mutate single-cells and arrays from IO
• Create pointers with various semantics supported by the language runtime

In this video, we will look at the wide variety of side-effects supported by the IO monad.

• Call C functions from IO, this is where most of the side-effects come from
• Mutate single-cells and arrays from IO
• Create pointers with various semantics supported by the language runtime

In this video, we will look at the wide variety of side-effects supported by the IO monad.

• Call C functions from IO, this is where most of the side-effects come from
• Mutate single-cells and arrays from IO
• Create pointers with various semantics supported by the language runtime

Exception Handling In this video, you will learn the subtleties of exception handling in Haskell, including why throwing exceptions is one of the only side-effect which isn't tracked by Haskell's type system.

• A brief overview of the IO half of the exception handling API
• Learn how to guard resources in the presence of exceptions
• The other half: throwing exceptions from pure code

Exception Handling In this video, you will learn the subtleties of exception handling in Haskell, including why throwing exceptions is one of the only side-effect which isn't tracked by Haskell's type system.

• A brief overview of the IO half of the exception handling API
• Learn how to guard resources in the presence of exceptions
• The other half: throwing exceptions from pure code

Exception Handling In this video, you will learn the subtleties of exception handling in Haskell, including why throwing exceptions is one of the only side-effect which isn't tracked by Haskell's type system.

• A brief overview of the IO half of the exception handling API
• Learn how to guard resources in the presence of exceptions
• The other half: throwing exceptions from pure code

Exception Handling In this video, you will learn the subtleties of exception handling in Haskell, including why throwing exceptions is one of the only side-effect which isn't tracked by Haskell's type system.

• A brief overview of the IO half of the exception handling API
• Learn how to guard resources in the presence of exceptions
• The other half: throwing exceptions from pure code

In this video, you will learn the subtleties of exception handling in Haskell, including why throwing exceptions is one of the only side-effect which isn't tracked by Haskell's type system.

• A brief overview of the IO half of the exception handling API
• Learn how to guard resources in the presence of exceptions
• The other half: throwing exceptions from pure code

In this video, you will learn the subtleties of exception handling in Haskell, including why throwing exceptions is one of the only side-effect which isn't tracked by Haskell's type system.

• A brief overview of the IO half of the exception handling API
• Learn how to guard resources in the presence of exceptions
• The other half: throwing exceptions from pure code

Fewer Sins Using the Free Monad In this video, we will try to understand why so many different kinds of side-effects live in the IO monad, as opposed to a more fine-grained system with multiple monads each responsible for tracking one effect. Then, we will create our own fine-grained effect-tracking monads.

• A simple module-based implementation of an effect-tracking monad
• A list-based implementation which simplifies testing
• Use a free monad to allow our implementation to support more complex computations

Fewer Sins Using the Free Monad In this video, we will try to understand why so many different kinds of side-effects live in the IO monad, as opposed to a more fine-grained system with multiple monads each responsible for tracking one effect. Then, we will create our own fine-grained effect-tracking monads.

• A simple module-based implementation of an effect-tracking monad
• A list-based implementation which simplifies testing
• Use a free monad to allow our implementation to support more complex computations

Fewer Sins Using the Free Monad In this video, we will try to understand why so many different kinds of side-effects live in the IO monad, as opposed to a more fine-grained system with multiple monads each responsible for tracking one effect. Then, we will create our own fine-grained effect-tracking monads.

• A simple module-based implementation of an effect-tracking monad
• A list-based implementation which simplifies testing
• Use a free monad to allow our implementation to support more complex computations

Fewer Sins Using the Free Monad In this video, we will try to understand why so many different kinds of side-effects live in the IO monad, as opposed to a more fine-grained system with multiple monads each responsible for tracking one effect. Then, we will create our own fine-grained effect-tracking monads.

• A simple module-based implementation of an effect-tracking monad
• A list-based implementation which simplifies testing
• Use a free monad to allow our implementation to support more complex computations

In this video, we will try to understand why so many different kinds of side-effects live in the IO monad, as opposed to a more fine-grained system with multiple monads each responsible for tracking one effect. Then, we will create our own fine-grained effect-tracking monads ing mechanism can be used to express effectful stream transformations.

• Introducing unsafeInterleaveIO by contrasting it with unsafePerformIO
• Introducing lazy IO by contrasting it with ordinary, strict IO
• Introducing effectful stream transformations by contrasting them with pure stream transformations

Simple Streaming Using Lazy IO...