 Resources from Brian Lonsdorf in 2024

This course teaches the ubiquitous abstractions for modeling pure functional programs. Functional languages have adopted these algebraic constructs across the board as a way to compose applications in a principled way. 

We can do the same in JavaScript. While the subject matter will move beyond the functional programming basics, no previous knowledge of functional programming is required. You'll start composing functionality before you know it.

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

Professor Frisby Introduces Composable Functional JavaScript

We see three varied examples of where natural transformations come in handy.

Apply Natural Transformations in everyday work

In this video we define monoids and promote our semigroups

Ensure failsafe combination using monoids

We rewrite the Box example using lazy evaulation

Delay Evaluation with LazyBox

We use semigroups to find the intersection of sets, then expand that to work on as many artists as we'd like. Finally, we use foldable to show a pair of intersection and sum to shed more light on the final result set.

Find the intersection of sets with Semigroups

We refactor 3 functions, taking line by line imperative code to a single composed expression using Box container type.

Refactor imperative code to a single composed expression using Box

We examine the data structure Task, see some constructors, familiar methods, and finally how it captures side effects through laziness.

Capture Side Effects in a Task

We examine the `of` function we've seen on a few types and discover it's the Pointed interface.

Lift into a Pointed Functor with of

A gallery of monoid definitions and some use cases

A curated collection of Monoids and their uses

We refactor a standard node callback style workflow into a composed task-based workflow.

Use Task for Asynchronous Actions

We find a couple of DOM nodes that may or may not exist and run a calculation on the page height using applicatives.

 Apply multiple functors as arguments to a function (Applicatives)

We take our Promise.all() analogy further by using traversable on a Map(). Then we use two traversals in the same workflow.

Maintaining structure whilst asyncing

We define the Either type and see how it works. Then try it out to enforce a null check and branch our code.

Enforce a null check with composable code branching using Either

We learn what a natural transformation is and see the laws it must obey. We will see how a natural transformation must uphold the law of nt(x).map(f) == nt(x.map(f)).

Principled type conversions with Natural Transformations

We discover, we've been using monads! We look a little further into the `chain` method and see laws that ensure the monadic structure works correctly.

You've been using Monads

We flesh out the Spotify api with pure functional constructs to retrieve two sets of related artists.

Retrieve and use data from an api with pure functional constructs

We use the traversable instance on List to reimplement Promise.all() type functionality.

Leapfrogging types with Traversable

We annihilate the need for the ol' nested `for` loop using Applicatives.

List comprehensions with Applicative Functors

An introduction to concatting items via the formal Semi-group interface. Semi-groups are simply a type with a concat method that are associative. We define three semigroup instances and see them in action.

Create types with Semigroups

We see what it means to curry a function, then walk through several examples of curried functions and their use cases.

Build curried functions

We formally define isomorphisms, make a few, then use them to accomplish normal programming tasks

Topics

Instructors

Content Type

Brian Lonsdorf