Published
Edited
Apr 28, 2021
1 fork
Result = ({
Ok: (data) => ({ type: 'Ok', data }),
Err: (data) => ({ type: 'Err', data })
})
function match(err, ok, variant) {
switch(variant.type) {
case 'Ok':
return ok(variant.data);
case 'Err':
return err(variant.data);
default:
return null;
}
}
{
const Val = ['hello'];
const Uppercase = (str) => [to_uppercase(str)];
const Exclaim = (str) => [exclaim(str)];
const one = Val.flatMap(Uppercase).flatMap(Exclaim);
const two = Val.flatMap(v => Uppercase(v).flatMap(Exclaim));
return [one.join(','), two.join(',')];
}
function to_uppercase(str) {
return str.toUpperCase();
}
function exclaim(str) {
return str + '!!';
}
function chain(ok, data) {
return match(Result.Err, ok, data);
}
chain_assoc_one = {
const Val = Result.Ok('hello');
const Uppercase = (str) => Result.Ok(to_uppercase(str));
const Exclaim = (str) => Result.Ok(exclaim(str));
return chain(Exclaim, chain(Uppercase, Val));
}
chain_assoc_two = {
const Val = Result.Ok('hello');
const Uppercase = (str) => Result.Ok(to_uppercase(str));
const Exclaim = (str) => Result.Ok(exclaim(str));
return chain(v => chain(Exclaim, Uppercase(v)), Val);
}
function unwrap(data) {
return match(Result.Err, value => value, data);
}
unwrap(chain_assoc_one) === unwrap(chain_assoc_two)
{
const Val = ['hello'];
const Id = Val.map(identity);
return [Val.join(', '), Id.join(', ')];
}
function identity(arg) {
return arg;
}
{
const Val = ['hello'];
const one = Val.map(v => exclaim(to_uppercase(v)));
const two = Val.map(to_uppercase).map(exclaim);
return [one.join(', '), two.join(', ')];
}
function map(fn, data){
return chain(v => Result.Ok(fn(v)), data);
}
functor_iden_one = {
return map(identity, Result.Ok('hello'));
}
functor_iden_two = {
return Result.Ok('hello');
}
unwrap(functor_iden_one) === unwrap(functor_iden_two);
functor_comp_one = {
const Val = Result.Ok('hello');
return map(v => exclaim(to_uppercase(v)), Val);
}
functor_comp_two = {
const Val = Result.Ok('hello');
return map(exclaim, map(to_uppercase, Val));
}
unwrap(functor_comp_one) === unwrap(functor_comp_two)
function ap(result, data) {
return chain(v => map(fn => fn(v), result), data);
}
apply_comp_one = {
const Val = Result.Ok('hello');
const composition = fx => gx => arg => fx(gx(arg));
const Uppercase = Result.Ok(to_uppercase);
const Exclaim = Result.Ok(exclaim);
return ap(ap(map(composition, Exclaim), Uppercase), Val);
}
apply_comp_two = {
const Val = Result.Ok('hello');
const Uppercase = Result.Ok(to_uppercase);
const Exclaim = Result.Ok(exclaim);
return ap(Exclaim, ap(Uppercase, Val));
}
unwrap(apply_comp_one) === unwrap(apply_comp_two);
{
const Title = Result.Ok('Dr. ');
const Name = Result.Ok('Acula');
const concat = (one, two) => one.concat(two);
return liftA2(concat, Title, Name);
}
function liftA2(fn, R1, R2) {
const curried = a => b => fn(a, b);
return ap(map(curried, R1), R2);
}
function liftA3(fn, R1, R2, R3) {
const curried = a => b => c => fn(a, b, c);
return ap(ap(map(curried, R1), R2), R3);
}
liftN = {
function curry(arity, fn, ...args) {
if(arity <= args.length) {
return fn(...args);
}
return curry.bind(null, arity, fn, ...args);
}
const apply = (arg, fn) => fn(arg);
const pipe = (fns) => (arg) => fns.reduce(apply, arg);
return function(fn, R1, ...RN) {
const arity = RN.length + 1;
const curried = curry(arity, fn);
const flipped = data => R => ap(R, data);
const _ap = pipe(RN.map(flipped));
return _ap(map(curried, R1));
}
}
{
const concat = (one, ...rest) => one.concat(...rest);
return liftN(
concat,
Result.Ok('Hello, '),
Result.Ok('Dr'),
Result.Ok('. '),
Result.Ok('Acula'),
Result.Ok('!!')
);
}
Promise.resolve('hello').then(to_uppercase);
(new Promise((resolve, reject) => { resolve('hello'); }))
.then(to_uppercase);
function of(value) {
return Result.Ok(value);
}
applicative_iden_one = {
return ap(of(identity), Result.Ok('hello'));
}
applicative_iden_two = {
return Result.Ok('hello');
}
unwrap(applicative_iden_one) === unwrap(applicative_iden_two);
applicative_hom_one = {
return ap(of(exclaim), of('hello'));
}
applicative_hom_two = {
return of(exclaim('hello'));
}
unwrap(applicative_hom_one) === unwrap(applicative_hom_two);
applicative_inter_one = {
const value = 'hello';
const Exclaim = of(exclaim);
return ap(Exclaim, of(value));
}
applicative_inter_two = {
const value = 'hello';
const Exclaim = Result.Ok(exclaim);
return ap(of(fn => fn(value)), Exclaim);
}
unwrap(applicative_inter_one) === unwrap(applicative_inter_two);
monad_li_one = {
return chain(exclaim, of('hello'));
}
monad_li_two = {
return exclaim('hello');
}
monad_li_one === monad_li_two;
function get_config() {
const config = fakeLocalStorage.getItem('config');
return config
? Result.Ok(config)
: Result.Err({ message: 'Config not found' });
}
function safe_parse(data) {
try {
return Result.Ok(JSON.parse(data));
} catch(e) {
return Result.Err(e);
}
}
map(safe_parse, get_config());
of('{"dark-mode":true}');
{
const one = chain(identity, of('{"dark-mode":true}'));
const two = identity('{"dark-mode":true}');
return [one, two];
}
function join(data) {
return match(Result.Err, identity, data);
}
join(map(safe_parse, get_config()));
chain(safe_parse, get_config());
monad_ri_one = {
return chain(of, Result.Ok('hello'));
}
monad_ri_two = {
return Result.Ok('hello');
}
unwrap(monad_ri_one) === unwrap(monad_ri_two);
function simpler_map(fn, data){
return chain(v => of(fn(v)), data);
}
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
