dtipson

function throttle(fn, threshhold = 250, scope) {
  var last,
      deferTimer;
  return function () {
    var context = scope || this;

    var now = +new Date,
        args = arguments;
    if (last && now < last + threshhold) {
      // hold on to it

dtipson

document.body.innerHTML = '';

const delay = milliseconds => x => new Promise(resolve => setTimeout(resolve, milliseconds, x));

//requestRecord :: Object (optional) -> Promise Stream
const requestRecord = (config={video:true, audio:true}) => {
  return navigator.mediaDevices && navigator.mediaDevices.getUserMedia ?
    navigator.mediaDevices.getUserMedia(config).then(delay(1400)) : // delay avoid startup flash
    Promise.reject('no support for getUserMedia');

dtipson

// mapping over an array with an async function
// would return an Array of Promises which isn't 
// super useful to work with on its own

async function fooPromise(x){ 
  return Promise.resolve(x*3);
}

const arr = [6,7,8,9];// -> [Promise[18],Promise[21],Promise[24],Promise[27]]]

dtipson

const getProp = prop => object => object[prop]
function KeyedCollection (Iterable, prop){
  if (!(this instanceof KeyedCollection)) {
    return new KeyedCollection(Iterable, prop);
  }
  if(!prop){
    throw new Error('must supply a prop')
  }
  const it_target = []
  const selectPropFrom = getProp(prop)

dtipson

// Finally wrapped your head around Promises? Time to toss out all that knowledge and learn the functional alternative!

// Here's a super simple implementation of a Task "type" 
const __Task = fork => ({fork})

// Absurdly simple! All we're doing is using a function that returns some unknown value, by name, in an object. 
// At this point "fork" is just a cute name though: what matters is how we use it.
// What makes Task a "Task" is that is that the "fork" value here... will be a higher-order function.

// Here's a usage example, already fully functional, already nearly as powerful as Promise!

dtipson

var object = {
  value:5,
  increment(){ return ++this.value; }
};

/*
But of course, even though that value is central to what the object is, 
it's not really a _primitive_ value in the sense that we can directly coerce it into a number or string:
*/

dtipson

/*
So, let's play with some Semigroups and (maybe?) Monoids for combining lists in interesting ways
*/

//This one is pretty straightforward
//Union (keep all values from both lists, but no repeats)
const Union = function(xs){
  if (!(this instanceof Union)) {
    return new Union(xs);
  }

dtipson

// Let's make it possible to create pure functions even when we're 
// dealing with impure operations that would have side effects!

// First we'll need a "Type" that can contain a (sometimes impure) function
function IO(fn) {
  if (!(this instanceof IO)) {//make it simpler for end users to create a type without "new"
    return new IO(fn);
  }
  this.runIO = fn;//IO now provides an extra control layer that allows the composition of unexecuted effects

dtipson

/*
  Native Arrays are not great structures for cellular automata.
  Non-empty, circular, doubly-linked lists would be ideal...
  but all we really need to do is write a comonadic-like interface 
  such that it _pretends_ that the array is circular, and can thus
  pass the exfn below a sort of "local" slice of an Array as if it were circular. 
  So you can mostly ignore the implementation mess below
*/
Array.prototype.extendNear = function(exfn){
  const len = this.length;

dtipson

// Let's make it possible to create pure functions even when we're 
// dealing with impure operations that would have side effects!

// First we'll need a "Type" that can contain a (sometimes impure) function
function IO(fn) {
  if (!(this instanceof IO)) {//make it simpler for end users to create a type without "new"
    return new IO(fn);
  }
  this.runIO = fn;//IO now provides an extra control layer that allows the composition of unexecuted effects