How to use daggy - 10 common examples

'use strict';

const {tagged, taggedSum} = require('daggy');
const {compose, identity} = require('fantasy-combinators');
const {of, chain, concat, map, ap, sequence} = require('fantasy-land');

const Either = taggedSum({
    Left:  ['l'],
    Right: ['r']
});

// Methods
Either.prototype.fold = function(f, g) {
    return this.cata({
        Left: f,
        Right: g
    });
};
Either[of] = Either.Right;
Either.prototype.swap = function() {
    return this.fold(
        (l) => Either.Right(l),
        (r) => Either.Left(r)

/* @flow */

import daggy from "daggy";

import { interpreter, send } from "./eff.js";

const Reader = daggy.taggedSum("Reader", {
	get: [],
});

export const get = () => send(Reader.get);

export const interpretReader = (i: any) =>
	interpreter({
		predicate: x => Reader.is(x),
		handler: readerEffect =>
			readerEffect.cata({
				get: () => continuation => continuation(i),
			}),
	});

/* @flow */

import daggy from "daggy";

import { interpreter, send } from "./eff.js";

const State = daggy.taggedSum("State", {
	get: [],
	modify: ["modificationFunction"],
	put: ["newState"],
});

export const get = () => send(State.get);
export const modify = (modificationFunction: any => any) =>
	send(State.modify(modificationFunction));
export const put = (newState: mixed) => send(State.put(newState));

export const interpretState = (startingState: mixed) => {
	let state = startingState;

	return interpreter({
		predicate: x => State.is(x),
		handler: stateEffect =>

const {tagged} = require('daggy');
const {nested, Tuple} = require('../fantasy-tuples');
const {isNumber, isString, isInstanceOf} = require('fantasy-helpers');
const env = require('fantasy-environment')();

const Sum = tagged('x');

Sum.prototype.equals = function(b) {
    return Setoid(λ).equals(this, b);
}

const λ = env
    .method('concat', isString, (a, b) => a + b)
    .method('map', isString, (a, f) => f(a))
    .method('equals', isString, (a, b) => a === b)
    .method('concat', isNumber, (a, b) => a + b)
    .method('map', isNumber, (a, f) => f(a))
    .method('equals', isNumber, (a, b) => a === b);

function Monoid(a) {
    return {
        empty: () => Sum(0),

'use strict';

const {tagged} = require('daggy');
const Product = tagged('x');

Product.of = Product;
Product.empty = () => Product(1);
Product.prototype.chain = function(f) {
    return f(this.x);
};
Product.prototype.concat = function(x) {
    return this.chain(a => x.map(b => a * b));
};
Product.prototype.map = function(f) {
    return this.chain(x => Product.of(f(x)));
};

module.exports = Product;

'use strict';

const daggy = require('daggy');

const {compose, identity} = require('fantasy-combinators');
const {Free} = require('./../fantasy-frees');
const Coproduct = require('fantasy-coproducts');
const IO = require('fantasy-io');


const FPrint = daggy.tagged('s', 'a');
const FRead = daggy.tagged('f');
const unit = daggy.tagged('x');
const Unit = () => unit('');

const Logger = daggy.taggedSum({
    Error: ['x', 'a'],
    Debug: ['x', 'a']
});

FPrint.prototype.map = function(f) {
    return FPrint(this.s, f(this.a));
};

FRead.prototype.map = function(f) {
    return FRead(compose(f)(this.f));
};

'use strict';

const {tagged} = require('daggy');
const {empty, of, concat} = require('fantasy-land');

const Unit = tagged('x');

Unit[empty] = () => Unit({});
Unit[of] = Unit[empty];

Unit.prototype[concat] = function(y) {
    return Unit({});
};

module.exports = Unit;

'use strict';

const daggy = require('daggy');

const {compose, constant, identity} = require('fantasy-combinators');
const {Free} = require('./../fantasy-frees');
const {Tuple2} = require('fantasy-tuples');
const {Lens}  = require('fantasy-lenses');
const State = require('fantasy-states');

const Forth = daggy.taggedSum({
    Push: ['a', 'next'],
    Add:  ['next'],
    Mul:  ['next'],
    Dup:  ['next'],
    End:  ['next']
});
const unit = daggy.tagged('x');
const Unit = () => unit('');

Forth.prototype.toString = function() {
    const named = (name) => (x) => 'Forth.' + name + '(' + x + ')';
    return this.cata({
        Push: (x, y) =>'Forth.Push(' + x + ', ' + y.toString() + ')',
        Add: named('Add'),
        Mul: named('Mul'),
        Dup: named('Dup'),

'use strict';

const daggy = require('daggy');

const {compose, identity} = require('fantasy-combinators');
const {Free} = require('./../fantasy-frees');
const Coproduct = require('fantasy-coproducts');
const IO = require('fantasy-io');


const FPrint = daggy.tagged('s', 'a');
const FRead = daggy.tagged('f');
const unit = daggy.tagged('x');
const Unit = () => unit('');

const Logger = daggy.taggedSum({
    Error: ['x', 'a'],
    Debug: ['x', 'a']
});

FPrint.prototype.map = function(f) {
    return FPrint(this.s, f(this.a));
};

FRead.prototype.map = function(f) {
    return FRead(compose(f)(this.f));
};

Logger.prototype.map = function(f) {
    return this.cata({
        Error: (a, b) => Logger.Error(a, f(b)),
        Debug: (a, b) => Logger.Debug(a, f(b))

Identity.IdentityT = (M) => {
    const IdentityT = daggy.tagged('run');
    IdentityT.lift = IdentityT;
    IdentityT.of = (a) => IdentityT(M.of(a));
    IdentityT.prototype.chain = function(f) {
        return IdentityT(this.run.chain((x) => f(x).run));
    };
    IdentityT.prototype.map = function(f) {
        return this.chain((a) => IdentityT.of(f(a)));
    };
    IdentityT.prototype.ap = function(a) {
        return this.chain((f) => a.map(f));
    };
    return IdentityT;
};