raganwald

let Person = (() = > {
  let firstNameProperty = Symbol('firstName'),
      lastNameProperty  = Symbol('lastName'),
      renameMethod      = Symbol('rename');

  return class Person {
    constructor (first, last) {
      this[renameMethod](first, last);
    }
    fullName () {

raganwald

# See https://twitter.com/fogus/status/623312803345117184

def meth a, b, c
  [yield(a), yield(b), yield(c)]
end

meth(1, 2, 3) { |x| x * x }
  # => [1, 4, 9]
  
arr = [1962, 6, 14, lambda { |x| x.to_s }]

raganwald

Many an idea or concept not only looks, but is good in its infancy, yet turns destructive later in life. Scaling and maturation are not the obvious processes they appear to be because they take so much time that the accumulated effort is easy to overlook.

To be successful, they must also be very carefully guided by people who can envision the end result, but that makes it appear to many as if it merely "happens." Take a good idea out of its infancy, let it age without guidance so it does not mature, and it generally goes bad.

—Erik Naggum on XML

raganwald

const evenStevens = (n) => {
  if (n === 0) {
    return true;
  }
  else if (n == 1) {
    return false;
  }
  else {
    n = n - 2;
    return evenStevens(n);

raganwald

// I expect:

doSomething().then(doSomethingElse())
  .then(finalHandler);

// To act like:

/*
doSomething
|-----------------|

raganwald

function * zipWith (zipper, ...iterables) {
  const iterators = iterables.map(i => i[Symbol.iterator]());

  while (true) {
    const pairs = iterators.map(j => j.next()),
          dones = pairs.map(p => p.done),
          values = pairs.map(p => p.value);

    if (dones.indexOf(true) >= 0) break;
    yield zipper(...values);

raganwald

function * append (...iterables) {
  for (const iterable of iterables) {
    yield * iterable;
  }
}

const lyrics = append(["a", "b", "c"], ["one", "two", "three"], ["do", "re", "me"]);

for (const word of lyrics) {
  console.log(word);

raganwald

function * nullEveryNth (skipFirst, n, iterable) {
  const iterator = iterable[Symbol.iterator]();

  yield * take(skipFirst, iterator);

  while (true) {
    yield * take(n - 1, iterator);
    iterator.next();
    yield null;
  }

raganwald

function * multiplesOf (startingWith, n) {
  let number = startingWith;
  
  while (true) {
    yield number;
    number = number + n;
  }
}

class HashSieve {

raganwald

function * just (...values) {
  yield * values;
};

function first (iterable) {
  const iterator = iterable[Symbol.iterator]();

  const { done, value } = iterator.next();
  if (!done) return value;
};