This package implements a style of free monads which is identical to
operational,
a Haskell package by Heinrich Apfelmus. The biggest difference to other variants of free monads is that
it uses an intermediate representation for the continuation structure, instead of only Pure and Impure, which
can be transformed into the "classical" form, which is here called ProgramView.
This leaves the possibility to write recursive interpreters directly over views, instead of always having to transform commands into a monadic representation (I think this can be more confusing to beginners). However, monadic interpretation is still supported.
Additionally, a "do notation" hack via generator functions is provided. Also, it makes much use of
daggy to automatically produce nicely usable sum types and allow for
some pattern-matching-like syntax.
Currently, only
npm install https://github.com/phipsgabler/operajonal.git
Can be found in examples/stacks.js. Basically, a clone of the stack interpreter
example from operational, but with an additional command Add. First, we need to define the
commands we are going to use:
const StackInstr = makeInstructions({
Push: ['value'],
Pop: [],
Add: []
});
const {Push, Pop, Add} = StackInstr;
Under the hood, makeInstructions produces a daggy sum type and wraps its constructors into the Instr
constructor of Program, the internal representation.
Now, suppose this is the monadic program we want to run:
Push(10).andThen(Push(20))
.andThen(Add())
.andThen(Push(33))
.andThen(Pop()).chain(
thirtyTwo => Pop().chain(
sum => Program.inject([sum, thirtyTwo])));
For convenience, we can also write that in do-notation:
const testProgram = Program.do(function*() {
yield Push(10);
yield Push(20);
yield Add;
yield Push(33);
let thirtyTwo = yield Pop;
let sum = yield Pop;
return `last element: ${thirtyTwo}, sum of previous: ${sum}`;
});
Given this, we can write a simple recursive interpreter for it. We do not need to manually deal with views, but
can directly give a catamorphism to the interpret method of Program:
const interpreter = (program, initialStack) => program.interpret({
Pop: recur => {
const [first, ...rest] = initialStack;
return interpreter(recur(first), rest);
},
Push: (recur, x) => interpreter(recur({}), [x, ...initialStack]),
Add: recur => {
const [first, second, ...rest] = initialStack;
const sum = first + second;
return interpreter(recur(sum), [sum, ...rest]);
}
});
For every instruction, we provide a case function taking the current continuation (here called recur), and the
properties of the instruction. The function should do whatever interpretation is necessary, then call the
continuation on the result, and recursively interpret the new program.
This interpreter can be run with
console.log(interpreter(testProgram(), []));
and should produce the result
last element: 33, sum of previous: 30
Alternatively, we can use monadic interpretation, e.g. into the State monad. For that, we do not have to write our own recursion, but simply translate each instruction into a new monadic action. These will then automatically be chained, and the resulting monadic action can be handled as needed:
function monadicInterpreter(program) {
return program.interpretMonadic({
Return: State.of,
Pop: () => State.get().chain(stack => {
const [first, ...rest] = stack;
return State.put(rest).andThen(State.of(first));
}),
Push: (x) => State.modify(stack => [x, ...stack]),
Add: () => State.get().chain(stack => {
const [first, second, ...rest] = stack;
const sum = first + second;
return State.put([sum, ...rest]).andThen(State.of(sum));
})
});
}
Note that here, we also have to provide a case for Return, providing the monad's constructor (it is assumed that
the binding method is called chain).
We can run this (assuming our State monad has a run method) with:
console.log(monadicInterpreter(testProgram()).run([]));
and it should produce a result equivalent to above.
This package is licensed under the MIT license.