gbracha / metaclasses Goto Github PK

class B<T extends A.class> {
  T GetBySmth() {
    return T.new(); // could even be new T() if we went that far
  }
}

class A {
   static int s() => 3;
   int d() => 4;
}

// B is parameterized over class types subtyping A.class
// B has a method foo which given a Type object
// implementing the interface of A.class, returns it.
// B also has a method bar which will instantiate T, producing an instance
// of some subtype of A.
class B<T extends A.class> extends A {
  B(int x);
  T foo(T c) => c;
  A bar() => T.new(); // known safe, since T extends A.class
}

// We can instantiate B as follows:
B b = new B<A.class>(0);
// Calling foo on a B returns the Type object for A, which has an s method which 
// returns an integer, but does not have a d method.
b.foo(A).s();  // ok  
b.foo(A).d(); // bad

// Calling bar on a B returns a new instance of A, which has a d method,
// but not an s method
b.bar().s(); // bad
b.bar().d(); // ok

// Even though B extends A, we cannot instantiate B with B.class, since B.class is not
// a subtype of A.class and hence does not satisfy the bound.
B badB = new B<B.class>(0); // bad
// If we ignore the type error, we can call bar, which tries
// to call the default constructor on B (which has none).
badB.bar(); // bad

// C is parameterized over instance types subtyping A
// C has a method foo which given a Type object implementing the interface of
// T.class, returns it. 
// C also has a method bar which will attempt to instantiate T and return an instance
// of a subtype of A.  If T has a default constructor,
// then the instantiation will succeed, but if not this will be a dynamic error.
class C<T extends A>  extends A {
  C(int x);
  T.class foo(T.class c) => c;
  A bar() => T.new(); // unsafe, may fail at runtime
}

// We instantiate C as follows:
C c = new C<A>(0);
// Calling foo on a C returns the Type object for A, which has an s method which 
// returns an integer, but does not have a d method.
c.foo(A).s();  // ok  
c.foo(A).d(); // bad

// Calling bar on a C returns a new instance of A, which has a d method,
// but not an s method
c.bar().s(); // bad
c.bar().d(); // ok

// We can instantiate C with anything that extends A
C okC = new C<C>(0); // ok
// But calling bar still blows up, since the call to new is dynamic and C has
// no default constructor.
okC.bar(); // bad

class Button extends Component {
  final tag = 'button';
  updateView() { updateRoot(vRoot()('Button Text')); }
}

// auto-generated {
createButton() => new Button();
vButton() => vComponent(createButton);
// }

class App extends Component {
  updateView() {
    if (state == 0) {
      updateRoot(vRoot()([
        vButton()
      ]));
    } else {
      updateRoot(vRoot()([
        vButton(),
        vButton()
      ]));
    }
  }
}

class Button extends Component { .. }

class App extends Component {
  updateView() {
    if (state == 0) {
      updateRoot(vRoot()([
        vComponent(Button)
      ]));
    } else {
      updateRoot(
        vRoot()([
          vComponent(Button),
          vComponent(Button)
        ])
      );
    }
  }
}

   abstract class LayoutManager { ... }
   void registerLayoutManager(Class<LayoutManager> manager, String name) { ... }

   class Foo {
     Foo() { print("constructor"); }
     static String get name => 'my-name';
     static void test() => print('foo');
   }
   void main() {
     var X = Foo;
     Foo f = new X(); // prints "constructor"
     print(X.name); // prints "my-name"
   }

   // assume Foo from above exists
   class Bar extends Foo {
     @override static String get name => 'bar';
     @override void test() { print('bar'); super.test(); }
   }
   void register(Class<Foo> x) {
     print("going to register ${x.name}");
   }
   void main() {
     Foo X = Bar;
     X.test(); // prints "bar" then "foo";
     register(X); // prints "going to register bar"
     register(Foo); // prints "going to register my-name"
   }

   abstract class Element {
     new(String input);
     static String get tagName;
     static bool isValid(String input);
     // ...
   }
   class FooElement extends Element {
     @override new(String input): super.new(input) { /*...*/ }
     @override static String get tagName => 'foo';
     @override static bool isValid(String input) => (input == 'true') || (input == 'false');
   }
   class BarElement extends Element {
     // inherits Element's constructor
     @override static String get tagName => 'bar';
     @override static bool isValid(String input) => (input == 'one') || (input == 'two');
   }
   Map<String, Class<Element>> registrations = {};
   registerElement(Class<Element> e) {
     registrations[e.tagName] = e;
   }
   instantiateElement(String tagName, String input) {
     var c = registrations[tagName](input);
     if (c.isValid(input))
       return new c(input);
     return null;
   }
   void main() {
     registerElement(FooElement);
     registerElement(BarElement);
     // ...
     assert(instantiateElement('foo', 'true') is FooElement);
     assert(instantiateElement('bar', 'one') is BarElement);
   }