Public
Edited
Oct 4, 2019
2 stars
data = [1,2,3,4,5]
data.map(x => x + 1);
data.filter(x => x > 2);
data
.map(x => x + 1)
.filter(x => x > 2);
reduce = (reducer, init, coll) => {
reducer = buildReducer(reducer);
if (coll === undefined) {
coll = init;
init = reducer.init();
}
if (init === undefined) {
init = reducer.init();
}
let result = init;
for (let x of coll) {
result = reducer.step(result, x);
}
return reducer.result(result);
}
addMapToReducer = (fn, reducer) => {
return (xs, x) => reducer(xs, fn(x));
}
plusOneToArray = addMapToReducer(x => x + 1, arrayConcatReducer)
reduce(plusOneToArray, [], data)
reduce(addMapToReducer(x => x + 1, sumReducer), 0, data)
md`### Transducer`
mapping = mapFn => reducer => {
return (xs, x) => reducer(xs, mapFn(x));
}
mapping(x => x + 1)(arrayConcatReducer)([1,2],5)
addOneTransducer = mapping(x => x + 1)
reduce(addOneTransducer(sumReducer), 5, data)
reduce(addOneTransducer(arrayConcatReducer), [], data)
reduce(addOneTransducer(objRandomKeyReducer), {}, new Set([55,56]))
filtering = pred => reducer => {
return (xs, x) => pred(x) ? reducer(xs, x) : xs
}
gtTwoTransducer = filtering(x => x > 2)
reduce(gtTwoTransducer(arrayConcatReducer), [], data)
reduce(gtTwoTransducer(sumReducer), 0, range(5))
transduce = (transducer, reducer, init, coll) => {
reducer = transducer(reducer);
return reduce(reducer, init, coll)
}
transduce(addOneTransducer, sumReducer, 0, data)
{
let reducer =
filtering(x => x > 2)(
mapping(x => x + 1)(
arrayConcatReducer
)
);
return reduce(reducer, [], [1,2,3,4,5])
}
compose2 = (f, g) => (...args) => f(g(...args))
compose = (...fns) => reduce(compose2, fns.shift(), fns);
{
let reducer = compose(
filtering(x => x > 2),
mapping(x => x + 1)
)(arrayConcatReducer)
return reduce(reducer, [], [1,2,3,4,5])
}
transduce(compose(
filtering(x => x > 2),
mapping(x => x + 1)
), arrayConcatReducer, [], [1,2,3,4,5])
{
function filterThenMapThenToArrayReducer(xs, x) {
if (x > 2) {
x = x + 1;
xs.push(x);
return xs;
} else {
return xs;
}
}
return reduce(filterThenMapThenToArrayReducer, [], [1,2,3,4,5])
}
flatten = reducer => (xs, x) => reduce(reducer, xs, x)
flatMap = fn => {
return compose(mapping(fn), flatten)
}
bufferCount = bufferSize => reducer => {
let n = 0, els = [];
return (xs, x) => {
els[n++] = x;
if (n === bufferSize) {
const result = els;
els = [];
n = 0;
return reducer(xs, result);
} else {
return xs
}
}
}
reduce(bufferCount(3)(arrayConcatReducer),[],[1,2,3,4,5,6])
{
const string = "I *!#* love you";
const transducer = compose(
flatMap(str => str.split(' ')),
filtering(x => x !== "*!#*"),
mapping(x => x === "you" ? x + "tube" : x)
);
return transduce(transducer, arrayConcatReducer, [], [string]).join(' ');
}
transduce(compose(
mapping(x => x * 2),
filtering(x => x > 5),
mapping(x => x + 1)
), sumReducer, 0, [1,2,3,4,5])
dropping = n => reducer => {
return (xs, x) => {
let toDrop = n;
if (toDrop === 0)
return reducer(xs, x)
else
toDrop--;
}
}
t1 = filtering(x => x > 2)
t2 = filtering(x => x > 3)
t = mapping(x => x + 1)
Type JavaScript, then Shift-Enter. Ctrl-space for more options. Arrow ↑/↓ to switch modes.
splitting = (transducers) => (reducers) => {
const keys = Object.keys(transducers);
const reds = keys.reduce((obj, k) => (obj[k] = transducers[k](reducers[k]), obj), {});
const xss = {};
return (xs, x) => {
return keys.reduce((obj, k) => (obj[k] = reds[k](xs[k], x),obj), {})
}
}
{
return transduce(compose(t,splitting({foo:t1, bar: t2})), {foo:arrayConcatReducer, bar: arrayConcatReducer}, {foo: [], bar: [] }, [1,2,3,4,5])
}
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.
