[Functional Programming Monad] Refactor Stateful Code To Use A State Monad

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.

Imaging we have a user object, if we want to udpate firstName prop, we have to update fullName as well.

const user =  {
    firstName: 'John',
    lastName: 'Green',
    fullName: 'John Green'
}

Code like this:

const _buildFulName = user => {
    const {firstName, lastName} = user;
    const fullName = joinName(firstName, lastName)
    return _updateFullName(fullName, user)
}
const _updateFirstName = curry(
    firstName => compose(
        _buildFulName,
        assign({firstName})
    )
)
const _updateFullName = curry(
    fullName => assign({fullName})
)

We want to use a more flexiable way to do it:

const getState = (key) => get(prop(key))
const getFirstName = () => getState('firstName').map(option(''));
const getLastName = () => getState('lastName').map(option(''));
const joinName = firstName => lastName =>  `${firstName}, ${lastName}`

const buildFullName = () => liftA2(
    joinName,
    getFirstName(),
    getLastName()
).chain(updateFullName)
const updateFirstName = firstName =>  modify(
    assign({firstName})
).chain(buildFullName);
const updateFullName = fullName =>  modify(
    assign({fullName})
)