You'll see all these techniques in action, including the Either and Task monads, in a real-world application fetching weather data. Prepare to change the way you write and think about front-end code forever!

Published: March 17, 2020

Table of Contents

Introduction
Introduction
00:00:00 - 00:00:53
Introduction
Brian introduces the course, and explains what the intended audience is.
Mathematical, Pure Functions
00:00:54 - 00:07:07
Mathematical, Pure Functions
Brian explores three small tests to determine if one is writing a function: the object needs to be total, have an input for every output, be deterministic, and have no observable side effects.
Pure Functions Checklist
00:07:08 - 00:14:05
Pure Functions Checklist
Brian reviews the checklist of what makes a mathematical, pure function, and asks the audience to determine if the examples presented are pure functions or not.
Pure Functions Advantages
00:14:06 - 00:15:46
Pure Functions Advantages
Brian explains how the mathematics used in functions can be useful when programming. Pure functions are reliable, portable, reusable, testable, and composable.
Currying
Properties, Arguments & Currying
00:15:47 - 00:26:00
Properties, Arguments & Currying
Brian explores the properties of a few calculation functions, and demonstrates how to write a curried function.
Currying Example & Argument Order
00:26:01 - 00:31:18
Currying Example & Argument Order
Brian gives the example of the filter function, curries it, explains the argument order, and imports the currying function from the Ramda library to be able to curry with more than two arguments.
Ramda Generalized Currying
00:31:19 - 00:35:24
Ramda Generalized Currying
Brian explains how to use the Ramba library while currying a function, and demonstrates how to write point free functions.
Partial Application vs Currying
00:35:25 - 00:36:49
Partial Application vs Currying
Brian explains that partial application and curried functions are dual functions. Partial application only uses one of its arguments, a curried function uses one argument at a time. The two functions have the same effect, but are written differently.
Currying Exercises
00:36:50 - 00:37:53
Currying Exercises
The students are instructed to code the solutions to various currying exercises.
Currying Solutions
00:37:54 - 00:46:20
Currying Solutions
Brian live codes the solution to the currying exercises.
Composition
Composition
00:46:21 - 00:52:06
Composition
Brian defines composition and gives examples of composed functions. A function is composed when it contains one function nested in the other, and returns a new function.
Creating Programs with Curry & Compose
00:52:07 - 00:58:35
Creating Programs with Curry & Compose
Brian demonstrates how to build a simple program using currying and compose, and argues that this way of writing code leads to consistent state mutations, but not efficient programming because of the absence of a clean data pipeline.
Composition is Dot Chaining
00:58:36 - 00:59:30
Composition is Dot Chaining
Brian explains that composition and dot chaining are the same, and says that dot chaining is more ergonomic in jаvascript.
Logging in Composition
00:59:31 - 01:01:22
Logging in Composition
Brian demonstrates how to use logging in function composition to debug code.
Compose Practice
01:01:23 - 01:10:33
Compose Practice
Brian demonstrates how to use compose in various examples, and rewrites functions into pipelines, making code easier to read.
Refactoring with Compose
01:10:34 - 01:15:37
Refactoring with Compose
Brian demonstrates how refactoring with function composition can make code easier to understand.
Refactoring to Point Free Style
01:15:38 - 01:19:28
Refactoring to Point Free Style
Brian demonstrates how to refactor functions using the point free style, explains that it allows parallelization and a better data processing workflow thanks to the high level declarative syntax.
Functors
Creating the Identity Functor
01:19:29 - 01:31:13
Creating the Identity Functor
Brian explains that a functor is a container that holds an object that is mapped over, demonstrates how to dot chain a function into a linear control flow, and explains that a functor is an object that has a map method. A functor is useful in functional programming because it abstracts function application.
Refactoring to Dot Chaining
01:31:14 - 01:34:02
Refactoring to Dot Chaining
Brian demonstrates how to use dot chaining with a functor and refactors the code written in the previous lesson.
Functor Practices
01:34:03 - 01:41:41
Functor Practices
Brian demonstrates how to use composition and sub-composition to nest functions. Nested functions are useful to have a clear idea of the data flow.
Adding Chain for Nested Functors
01:41:42 - 01:46:45
Adding Chain for Nested Functors
Brian demonstrates how to write a function that allows for chaining methods and argues that one could use promise.then instead, but in an effort to stay deterministic and mathematical, the use of chaining is better.
Either Monad
Either Monad
01:46:46 - 01:54:28
Either Monad
Brian explains that the type Either is a functor and a monad, it has both a map, a chain method, and a fold method. The Either type respects function purity and is effectively an if else statement, but inverted.
fromNullable
01:54:29 - 01:56:08
fromNullable
Brian explains that fromNullable is useful because it is a definitive null check for every function, and avoids repetition.
Refactoring Using the Either Monad
01:56:09 - 02:01:24
Refactoring Using the Either Monad
Brian demonstrates through a server example how to use the Either monad to refactor code.
Flattening Either Monads with Chain
02:01:25 - 02:04:40
Flattening Either Monads with Chain
Brian demonstrates how to flatten the Either monad using both the chain and map methods.
Adding Syntax vs Generalized Solutions
02:04:41 - 02:06:19
Adding Syntax vs Generalized Solutions
Brian recommends using the Either type instead of exploring specific syntax that only covers one unique way of using the type.
Either Practices
02:06:20 - 02:22:08
Either Practices
Brian goes over examples of using the Either type using the dot syntax, and explains that, when working with Either, it is not possible to flatten an array of another type.
Debugging with Logging
02:22:09 - 02:25:58
Debugging with Logging
Brian demonstrates how to use logs to debug the code, and answers questions about the Writer monad, a monad that, along with values, returns an error message.
Task
Task Monad
02:25:59 - 02:32:54
Task Monad
Brian explains that the Task monad is the functional equivalent of promise. Similarly to promise, Task takes resolve and reject functions, but in reversed order. A Task monad only starts running once it reaches the fork method, and this way avoids race conditions.
Refactoring Node IO with Task
02:32:55 - 02:39:37
Refactoring Node IO with Task
Brian explains that Node IO, although commonly used, does not bring in any asynchronicity, and demonstrates how to use Task instead which gives a clean control flow.
Task Practices
02:39:38 - 02:50:32
Task Practices
Brian goes over different Task monad examples and familiarizes the audience with the Task syntax, and characteristics.
Transforms & Monad Patterns
02:50:33 - 03:08:41
Transforms & Monad Patterns
Brian explores various transformations, such as type transformations, free monads, and monoids with both the either and task monad.
Inspecting the Weather API
03:08:42 - 03:13:58
Inspecting the Weather API
Brian demonstrates how to fetch weather data from the weather API, and explains the next data parsing steps.
Separate Pure & Impure Code
03:13:59 - 03:20:27
Separate Pure & Impure Code
Brian builds a task monad to fetch data from an API and refactors the code using the Task monad.
Creating a Weather Module
03:20:28 - 03:24:48
Creating a Weather Module
Brian demonstrates how to use the Task monad when creating a weather module, and how to use the monad in different places within the same application.
Parsing Weather API Data into HTML
03:24:49 - 03:37:50
Parsing Weather API Data into HTML
Brian uses HTML to show some of the results gathered through the weather API on the screen, live codes a weather data type, and refactors the code into new types, making the application cleaner, and the functions within it more accessible.
Wrapping Up
Wrapping Up
03:37:51 - 03:44:49
Wrapping Up
Brian wraps up the course, thanks the audience, reviews briefly what the course covered, and answers questions about naming in functional programming.

also You can find my other helpful
(if old file-links don't show activity, try copy-paste them to the address bar)

General
Complete name : 3. Refactoring Using the Either Monad.mp4
Format : WebM
Format version : Version 2
File size : 20.6 MiB
Duration : 5 min 15 s
Overall bit rate mode : Variable
Overall bit rate : 547 kb/s
Writing application : Lavf57.71.100
Writing library : Lavf57.71.100
FileExtension_Invalid : webm

Video
ID : 2
Format : VP8
Codec ID : V_VP8
Duration : 5 min 15 s
Bit rate : 325 kb/s
Width : 1 920 pixels
Height : 1 080 pixels
Display aspect ratio : 16:9
Frame rate mode : Constant
Frame rate : 29.970 (30000/1001) FPS
Compression mode : Lossy
Bits/(Pixel*Frame) : 0.005
Stream size : 12.2 MiB (59%)
Language : English
Default : Yes
Forced : No

Audio
ID : 1
Format : Vorbis
Format settings, Floor : 1
Codec ID : A_VORBIS
Duration : 5 min 15 s
Bit rate mode : Variable
Bit rate : 192 kb/s
Channel(s) : 2 channels
Sampling rate : 48.0 kHz
Compression mode : Lossy
Delay relative to video : -3 ms
Stream size : 7.22 MiB (35%)
Writing application : Lavc57.89.100
Writing library :
Language : English
Default : Yes
Forced : No Screenshots

✅ Exclusive eLearning Videos ← add to bookmarks
Feel free to contact me
when links are dead or want any repost