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

Dealing with stateful computations can be a challenge when writing purely functional JavaScript.
They can result in undesired variable declaration at best and boilerplate state management code
in every function dependent on the state at its worst.

In this course we will explore a well know Algebraic Data Type named State, that is built from
the ground up to address these 🌽cerns. While this course will be focused around a State
implementation provided by a library named [`crocks`](https://www.npmjs.com/package/crocks),
a majority of the techniques we learn here can be used with most of the State implementations
in the wild.

We define the State datatype and take a peek into its inner working. By manually constructing an instance, we’ll start to get a feel on how the type separates state management from our stateful computations. As State depends on a Pair type, we get to know how each portion can be extracted through the `fst` and `snd` Pair instance methods.

Construct a Stateful Monad

We explore our first stateful transaction, by devising a means to echo our state value into the resultant for independent modification. With our state value in the resultant, we explore using `map` to lift functions into our type as a means to modify the resultant.

In our exploration we find that not only can we change values of the resultant, but we can change the type as needed. We also find that we can combine subsequent map calls into function compositions, allowing us to clean up our code and combine our mappings to avoid excessive interactions with our `State` datatype.

To wrap it all up, we take a look at a handy `State` construction helper called `get` that we can use to query the state into resultant. This allows to read from our state for computations that are based on the value of a given state. 

Map And Evaluate State With A Stateful Monad

We take a closer look at the `get` construction helper and see how we can use it to lift a function that maps the state portion and updates the resultant with the result. Using `get` in this fashion, we then demonstrate how we can make accessors that can then be extended to create more complex interactions.

As there are times that we only want to pull the resultant for a given computation, we take a look at running our instances with the `evalWith` method. `evalWith` will run our computations, throwing away the state, returning the resultant.

Substitute State Using Functions With A State Monad

Stateful computations require the ability for their state to change overtime. We take a look on one way to replace the state portion of our stateful datatype with a value. We explore the mechanics of how this can be accomplished and introduce the `put` construction helper. We also see how we can run our instances with `execWith` to extract the state portion and discard the resultant.

Update The State Of A State Monad

Using `put` to update our state for a given state transaction can make it difficult to modify a given state based on its previous value. In this lesson we will explore a means to lift specialized functions that can be used modify our state’s value. These specialized functions must have the same type in their input and output. We take a look at a construction helper named `modify` that is used to remove the boilerplate of this type of construction. We also start to see how we can extend simple discrete stateful transactions to create other stateful transactions.

Modify The State Of A State Monad

The true power of the State ADT really shows when we start combining our discrete, stateful transactions. We start looking at another construction helper named `of`, used to lift any given value of any type into the resultant. We also explore another instance method called `chain` that is used for combining our simple, discrete transactions into more complex flows that can be extended to meet our needs as they arise. To create a set of stateful transactions to be combined, we see how the `get` and `modify` construction helpers can be used to make simple, easy to read code.

Combine Stateful Computations Using A State Monad

We explore a means to represent the combination of our stateful computations using familiar composition. We dive into what makes this possible by talking about what are known as Kleisli Arrows and explore some interesting properties surrounding them.

Once we understand the basics of how our stateful computations are chained, we look at how we can enlist a special compose helper named `composeK`. Using `composeK`, we show how we can further remove a lot of the boilerplate sometimes used to combine stateful computations.

Combine Stateful Computations Using Composition

When building our stateful computations, there will come a time when we’ll
need to combine two or more state transactions at the same time to come up
with a new result. Usually this occurs when want to use plain ol’ JavaScript
functions with two or more a arguments as part of our stateful computations.

We first look at how this can be accomplished by using `chain` and closure to
get access to both functions. Then we will explore how we can leverage the `of`
construction helper and the `ap` `State` instance method to clean this type of
interaction up a bit. We then conclude with an even cleaner approach that takes
full advantage of a `crocks` helper function named `liftA2`.

Apply Stateful Computations To Functions

When we start to accumulate functions that all work on a given datatype, we
end up creating a bunch of boilerplate code in almost every function to handle
the changes we need to make to our records’ values. This can lead to not only
undesirable boilerplate present in all of our functions, but also can cause us
to have to create variables just to manage our stateful changes.

We’ll take a look at a couple patterns that can act as early warning signs
that will eventually cause us to not have a good time. Once we know what the
smell is, we’ll look at how moving our computations into `State` can clean up
all of our state management code by making it the responsibility of `State`.
This allows our functions to only describe how state should change over time
versus us having to change it ourselves.


State Monad in JavaScript

Ian Hofmann-Hicks

Free Community Resource

Free Community Resource

Course Content