rbuckton

export class LinkedList {
    #head;
    #size;

    get first() { return this.#head; }
    get last() { return this.#head !== undefined ? this.#head.LinkedListNode#previous : undefined; }
    get size() { return this.#size; }

    addLast(value) {
        return this.#insertBefore(this.#head, new LinkedListNode(value), /*replaceHead*/ false);

rbuckton

// 
// definition
//

// marker used to indicate a constructor is a freeesing constructor (see below).
const marker = new WeakSet();

export function freeze(descriptor) {
    // save the previous constructor
    const previousConstructor = descriptor.constructor;

rbuckton

Introduction

This is a strawman for the inclusion of a new ClassProperty syntax:

class C {
  static f() { ... }
  
  g() {
 class.f();

rbuckton

const friendship = new WeakMap();

function friend(ref granteeClass) {
    return function (descriptor) {
        descriptor.finisher = (granterClass) => {
            let info = friendship.get(granterClass);
            if (!info) {
                const names = descriptor.elements
                    .filter(element => element.name instanceof PrivateName)
                    .reduce((map, element) => map.set(element.name.description, element.name), new Map());

rbuckton

Language-integrated Query syntax for ECMAScript

This is a strawman for an advanced generator-comprehension syntax for ECMAScript based in the LINQ syntax. The syntax allows for custom semantics for evaluation, as each clause in a query is translated into regular function calls for special symbol-named methods that are evaluated if found on the sequence (see Abstract Operations for more information).

Examples

rbuckton

declare type DateUnit = "year" | "month" | "day";
declare type DateDelta = "years" | "months" | "weeks" | "days";
declare type TimeUnit = "hour" | "minute" | "second" | "millisecond" | "nanosecond";
declare type TimeDelta = "hours" | "minutes" | "seconds" | "milliseconds" | "nanoseconds";
declare type InstantUnit = "milliseconds" | "nanoseconds";
declare type InstantDelta = "milliseconds" | "nanoseconds";
declare type Components<Unit extends string> = Partial<Record<Unit, number>>;
// Represents either a fixed-offset time-zone, the SYSTEM time-zone, or a regional (IANA) time-zone.
declare class Zone {
    static readonly Z: Zone;

rbuckton

Decorators, Take 4

A decorator is a function that returns a series of "hooks":

function dec() {
  return [
    { register(klass) { } },
    { register(target, key) { } },
    { wrap(f) { return f; } },
 { initialize(target, key, value) { } },

rbuckton

//
// Lexical Grammar
//

SourceCharacter::
  > Any unicode code point

WhiteSpace::
  <TAB>
  <VT>

rbuckton

Symbol.asyncDispose = Symbol.for("Symbol.asyncDispose");
function __asyncUsing(obj) {
    let state = obj !== null && obj !== undefined ? 0 : 2;
    return {
        [Symbol.asyncIterator]() { return this; },
        async next() {
            if (state) return this.return();
            state = 1;
            return { value: obj };
        },

rbuckton

export {};

/** A non-existent symbol used to define the types of events defined on an object */
declare const kEvents: unique symbol;

/** Gets the events defined on an object. */
type Events<T> = T extends { readonly [kEvents]: infer Events } ? Events : {};

/** Get the names of events defined on an object. */
type EventNames<T> = keyof Events<T>;