seaneagan

Proxy.ForwardingHandler.prototype = {
  create: function(target) {return {target: target}},
  getPrototypeOf: function (proxy, state) {
    return Object.getPrototypeOf(state.target);
  }
  // all other traps take state argument
};

// ... //

seaneagan

Object.sealProperty = function(object, property) {
  var pd = Object.getPropertyDescriptor(object, property) || {value: undefined};
  pd.configurable = false;
  return Object.defineProperty(object, property, pd);
};

Object.freezeProperty = function(object, property) {
  var pd = Object.getPropertyDescriptor(object, property) || {value: undefined};
  pd.configurable = false;
  pd.writable = false;

seaneagan

Object.defineProperty(Object, "extend", {
  "configurable": true,
  "enumerable": false,
  "value": function (object, extension) {

    // throw if either is not an object
    if(object !== Object(object)) {throw new TypeError;}
    if(extension !== Object(extension)) {throw new TypeError;}

seaneagan

Orthogonalized super keyword

There are two active proposals for what to do with the reserved word "super", [object initialiser super][] and [classes][]. Both proposals limit the context in which "super" can appear. This proposal attempts to allow "super" anywhere by basing it's behavior on ThisBindings.

Details

Execution contexts are updated to have a SuperBinding similar to the existing ThisBinding. The keyword "super" by itself evaluates to the value of the SuperBinding of the current execution context. Direct function calls, e.g. f() or f.call(this, arg), result in a SuperBinding of the [[Prototype]] internal property of the passed ThisBinding or undefined it the ThisBinding is not an object. Method calls, e.g. o.m(), and accessor property access, e.g. o.p where "p" is an accessor property somewhere in o's property lookup chain (own properties plus prototype chain), result in a SuperBinding which is the [[Prototype]] internal property of the object in o's property lookup chain on whic

seaneagan

/**
 * Proposal:  Refactoring Dart collections
 * 
 * Move accessors from Map, List, and Set into ReadableMap, ReadableList, and ReadableSet interfaces which Map, List, and Set extend
 * 
 * "const " prefixed map and list literals produce ReadableMap and ReadableList instances
 * 
 * Let ReadableMap<K, V> extend Collection<K>
 * 
 * Let List extend Queue

seaneagan

// mixin instead of a class ?
class CollectionImpl<E> implements Collection<E> {

  Iterable _wrapped;

  CollectionImpl(Iterable other) {
    this._wrapped = other;
  }

  Iterator<E> iterator() => _wrapped.iterator();

seaneagan

/** Strings are ReadableLists of chars */
interface String extends ReadableList<char>, Pattern {

  String(Iterable<int> other);

  // Accessors
  String            toLowerCase  (                            );
  String            toUpperCase  (                            );
  String            trim         (                            );
  String            getRange     (Range range                 ); // replaces subString

seaneagan

interface IsolateMirror {
  final LibraryMirror rootLibrary;
  StackMirror stack();
  MirrorGroup<LibraryMirror> imports;
  MirrorGroup<ReceivePort> ports; // not sure what is used as the name of a port
}


// invocation
interface InvocationMirror {

seaneagan

/**instance of Library*/
interface Isolate {
  final LibraryMirror library;  
}

interface LibraryMirror extends ScopeMirror {
  final LinkedHashMap<Import> imports;
  final LinkedHashMap<Source> sources;
  final Map <Dynamic> topLevels;
}

seaneagan

a::b
a::b=
a::+
a::[]=

a->b
a->b=
a->+
a->[]=