[Functional Programming Monad] Combine Stateful Computations Using Composition

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.

 

Code we have:

const { constant, composeK, Unit, curry, objOf, compose, State, mapProps, prop, option } = require("crocks");

const { put, get, modify } = State;


const add = x => y => x+y;
const inc = add(1);
const multipy = x => y => x * y;

// State s a -> State(x => Pair(a, x))

// 'get' return result apply to variable a
const addState = n => 
    get(add(n))

const incState = n => 
    modify(inc) // modify return Unit() in variable position, Pair( (), 3 )
    .map(constant(n)) // to keep the vairable a, we can use constant to wrap a value into function, Pair( 12, 3 )

const mutiplyState = n => 
    get(multipy(n));

const compute = n => 
    State.of(n)
        .chain(addState )
        .chain(incState)
        .chain(mutiplyState)


 console.log(
     compute(10)
        .runWith(2) // Pair(36, 3)
 )           

 

We want to compose some functions, for example:

const addState = n => 
    get(add(n))

const incState = n => 
    modify(inc)
    .map(constant(n))

Into:

const addAndInc =
    composeK(
        incState,
        addState
    )
const compute = n => 
    State.of(n)
        .chain(addAndInc)
        .chain(mutiplyState)

 

Here we are using composeK, because incState and addState they both return State Number, combine multi state opreation, we need to use composeK.

Another benifit we got from using composeK, is point-free function, because it will automaticlly lift the param into State.

// From
const compute = n => 
    State.of(n)
        .chain(addAndInc)
        .chain(mutiplyState)

// To:
const compute = n => 
    addAndInc(n)
        .chain(mutiplyState)

Means we don't need manully call 'State.of' anymore.

 

The same we can compose further:

// From
const compute = n => 
    addAndInc(n)
        .chain(mutiplyState)

// TO:
const compute = composeK(
    mutiplyState,
    addAndInc
);

composeK takes care for us :D

 

-- 

const { constant, composeK, Unit, curry, objOf, compose, State, mapProps, prop, option } = require("crocks");

const { put, get, modify } = State;


const add = x => y => x+y;
const inc = add(1);
const multipy = x => y => x * y;

// State s a -> State(x => Pair(a, x))

// 'get' return result apply to variable a
const addState = n => 
    get(add(n))

const incState = n => 
    modify(inc) // modify return Unit() in variable position, Pair( (), 3 )
    .map(constant(n)) // to keep the vairable a, we can use constant to wrap a value into function, Pair( 12, 3 )

const mutiplyState = n => 
    get(multipy(n));

const addAndInc =
    composeK(
        incState,
        addState
    )

const compute = composeK(
    mutiplyState,
    addAndInc
);


 console.log(
     compute(10)
        .runWith(2)
 )