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

JavaScript’s dynamic typing makes it incredibly flexible. That flexibility can lead to trouble though. When values have the potential to change types or to end up as `null` or `undefined`, that can lead to runtime errors in our code or bizarre bugs that take forever to track down because of type coercion. To battle this, we end up with code that is littered will conditionals for `null` or `undefined` values and type checks, making the core logic harder to read and refactor later. 

The **Maybe** encapsulates the type checking and guards against missing values for us. With **Maybe** in our toolbelt, we can keep our functions free of all the guardrails, outsource that work to the **Maybe** and keep our business logic free of all the clutter.

JavaScript's dynamic typing makes the language incredibly flexible. That flexibility comes at a cost. Because any variable can potentially be of any type, it's easy to inadvertently introduce runtime Type errors into an application.

The Maybe data type encapsulates the defensive coding needed to avoid such errors, keeping our application code focused on the task at hand.

In this course, we'll look at the Maybe type in action. We'll be relying on the Maybe exposed by the crocks library, but the core concepts and much of the API translates to other implementations. We'll learn how to construct a Maybe and apply transformations to data within those safe confines. We'll also cover point-free utility functions that let us build up function compositions for working with Maybes

After completing this course, you'll have the tools to write safe, declarative JavaScript that can be easily composed while avoiding the unnecessary noise of sprinkling imperative conditional statements throughout your code.

Course Introduction: Safer JavaScript with the Maybe type

In this lesson, we’ll get started with the Maybe type. We’ll look at the underlying Just and Nothing types and create a simple utility function to create a Maybe from a value. Then we’ll see how we can apply functions to values and skip invocation for values that might cause errors or unexpected results.

Understand the Maybe Data Type

In this lesson, we’ll create a `safe` function that gives us a flexible way to create `Maybe`s based on a value and a predicate function that we supply. We’ll verify its behavior with values that satisfy the predicate, and values that do not.

Create a Maybe with a `safe` Utility Function

Applying functions to values within the context of a Maybe means we can perform our transformations with more confidence. At some point, we’ll need to extract our value to use it in places where our code expects a raw value. In this lesson, we’ll see how to get the value back out of a Maybe.

Unwrap Values from a Maybe

In this lesson, we’ll use a Maybe to safely operate on properties of an object that could be undefined. We’ll use our initial code as the basis for a `prop` utility function that can be reused with different objects and various property names. Instead of just blindly asking for a property, this version of `prop` will drop us into the safe confines of a Maybe, giving us a `Just` when the property exists and a `Nothing` for an `undefined` property. Once we’ve built up our own `prop` utility, we’ll refactor the code one more time to take advantage of the built-in `prop` utility provided by the crocks library.

Safely Access Object Properties with `prop`

In this lesson, we’ll look at the `propPath` utility function. We’ll ask for a property multiple levels deep in an object and get back a Maybe. We’ll get a `Just` when the property exists at our path and a `Nothing` if any part of the path is `undefined`.

Safely Access Nested Object Properties with `propPath`

Sometimes, we run into situations where we end up with a Maybe within the context of another Maybe. Nested structures like this can get really confusing to work with. In this lesson, we’ll look at an example of this and see how `chain` can help us out by flattening the nested `Maybe`s

Flatten Nested Maybes with `chain`

Once we’re using Maybes throughout our code, it stands to reason that at some point we’ll get a Maybe and want to continue applying transformations. We might get a Nothing and want to perform those same transformations on some default value. In this lesson, we’ll do exactly that! We’ll see how we can use the `alt` method on the Maybe to recover from a Nothing and continue applying transformations with a Just.

Recover from a Nothing with the `alt` method

The `alt` method allows us to recover from a nothing with a default Maybe, but sometimes our recovery efforts might need to enlist some logic to recover properly. In this lesson, we’ll see how we can use the `coalesce` method on the Maybe to recover from a Nothing by calling a function.

Recover from a Nothing with the `coalesce` Method

We can dot-chain our way to great success with an instance of Maybe, but there are probably cases where you need to apply the same series of transformations against different `Maybe`s. In this lesson, we’ll look at some point-free versions of some common Maybe methods and see how we can compose them together to get a reusable function that can be applied to any Maybe instance.

Compose Functions for Reusability with the Maybe Type

Functions are first class in JavaScript. This means we can treat a function like any other data. This also means we can end up with a function as the wrapped value in a Maybe. The Maybe type gives us the ability to apply that wrapped function to other wrapped values, keeping both the value and the function in the safe confines of a Maybe.

Apply a function in a Maybe context to Maybe inputs

You probably have functions that aren’t equipped to accept a Maybe as an argument. And in most cases, altering functions to accept a specific container type isn’t desirable. You could use `map`, passing in your function, or you could “lift” your function into a `Maybe` context. In this lesson, we’ll look at how we can get a function that accepts raw values to work with our Maybe container without the need to modify the original function or the input values.

Safer JavaScript with the Maybe Type

Andy Van Slaars

Course Content