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);
}
One platform to build and deploy the best data apps
Experiment and prototype by building visualizations in live JavaScript notebooks. Collaborate with your team and decide which concepts to build out.
Use Observable Framework to build data apps locally. Use data loaders to build in any language or library, including Python, SQL, and R.
Seamlessly deploy to Observable. Test before you ship, use automatic deploy-on-commit, and ensure your projects are always up-to-date.