zenparsing

hex_values = ['626f6f74', '72616365', '626c6168', '6f6f7073']
packed_list = hex_values.map { |item| [item].pack('H*') }.sort().join()

zenparsing

/*

A map class, implemented with private slots, which has the following properties:

- The presence of a mapping k => v in a SlotMap does not by itself make k or v reachable
- For each mapping k => v in a SlotMap m (whether m is reachable or not), if k is reachable then v is reachable

*/
const DELETED = {};

zenparsing

import { deprecated } from './macros/deprecated.js';

// Using Rust-like syntax only to make it clear these
// are macros and not "decorators"

#[deprecated]
function dontUseMeAnymore() {
  eval('You wrote a bad song, Petey!');
}

zenparsing

Symbol Literals

The form @identifierName is a symbol literal. Within any single module or script, two identitical symbol literals refer to the same symbol. Two identical symbol literals in separate modules or scripts refer to different symbols. A symbol literal may appear as a propery name or as a primary expression.

When a symbol literal appears as a primary expression, it is shorthand for this.@identifierName.

When a symbol literal appears as a property name, the corresponding symbol is used as the property key during evaluation.

zenparsing

function* range(from, to) {
  for (let i = from; i <= to; ++i) {
    yield i;
  }
}

function take(source, n) {
  if (n <= 0) {
    return Observable.from([]);
  }

zenparsing

function once(el, event) {
  return new Promise((resolve, reject) =>  {
    const handler = e => {
      resolve(e);
      el.removeEventListener(event, handler); 
    };
    el.addEventListener(event, handler);
  });
};

zenparsing

let CustomEvent = window.CustomEvent;

if (typeof CustomEvent !== "function") {
    // Internet Explorer
    CustomEvent = function(name, options = {}) {
        let {
            bubbles = false,
            cancelable = false,
            detail
        } = options;

zenparsing

Observable.prototype[Symbol.asyncIterator] = async function*() {

    function promiseCapability() {
        x = {};
        x.promise = new Promise((a, b) => {
            x.resolve = a;
            x.reject = b;
        });
        return x;
    }

zenparsing

ES6 Module Loading in Node.js

Guiding Principles

• The solution must be 100% backward-compatible.
• In the far future, developers should be able to write Node programs and libraries without knowledge of the CommonJS module system.
• Module resolution rules should be reasonably compatible with the module resolution rules used by browsers.
• The ability to import a legacy package is important for adoption.

Design Summary

zenparsing

function takeUntil(control) {

    return new Observable(next => new Promise((resolve, reject) => {
        this.forEach(next).then(resolve, reject);
        control.forEach(resolve).catch(reject);
    }));
}

function switch() {