Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
'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;
};