Initial support for runtime function types and type checking

lib/runtime/dart/_internal.js

 var _internal;
 (function(exports) {
   'use strict';
   class EfficientLength extends core.Object {}
   let ListIterable$ = dart.generic(function(E) {
     class ListIterable extends collection.IterableBase$(E) {
       ListIterable() {
         super.IterableBase();
       }
       get [core.$iterator]() {
@@ skipping 330 matching lines @@
         this[_current] = this[_iterable][core.$elementAt](this[_index]);
         this[_index] = dart.notNull(this[_index]) + 1;
         return true;
       }
     }
     ListIterator[dart.implements] = () => [core.Iterator$(E)];
     return ListIterator;
   });
   let ListIterator = ListIterator$();
   let _Transformation$ = dart.generic(function(S, T) {
-    class _Transformation extends core.Function {}
+    let _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));

[Jennifer Messerly, 2015/04/09 18:44:28]

so, the reason I made it a class ... it seemed like function types are basically
a special case:

    typedef R Foo(T t, S s);

is sort-of sugar for:

    class Foo {
      R call(T t, S s);
    }

("sort-of" because nominal vs structural in type checks)

So once we had method type signatures, function types would "fall out" for free,
and we wouldn't need two ways of emitting type signatures: we could just read it
from the "call" method. Granted, we'd still need to mark typedefs, so they are
treated structurally instead of nominally :)

Taking this even further, in hypothetical ES7 we could do signatures like this:

    function printLabel(obj: string) {}

so maybe just polyfill that?

[vsm, 2015/04/09 19:52:24]

I had thought of this, but I found it confusing to conflate the two.  The
semantics are different - not just the nominal vs structural but the difference
in variance.  Type parameters are covariant in generics but not in typedefs.

     return _Transformation;
   });
   let _Transformation = _Transformation$();
   let _ = dart.JsSymbol('_');
   let _f = dart.JsSymbol('_f');
   let MappedIterable$ = dart.generic(function(S, T) {
     class MappedIterable extends collection.IterableBase$(T) {
       MappedIterable(iterable, func) {
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthMappedIterable$(S, T))(iterable, func);
@@ skipping 78 matching lines @@
       }
       [core.$elementAt](index) {
         return this[_f](this[_source][core.$elementAt](index));
       }
     }
     MappedListIterable[dart.implements] = () => [EfficientLength];
     return MappedListIterable;
   });
   let MappedListIterable = MappedListIterable$();
   let _ElementPredicate$ = dart.generic(function(E) {
-    class _ElementPredicate extends core.Function {}
+    let _ElementPredicate = dart.typedef('_ElementPredicate', () => dart.functionType(core.bool, [E]));
     return _ElementPredicate;
   });
   let _ElementPredicate = _ElementPredicate$();
   let WhereIterable$ = dart.generic(function(E) {
     class WhereIterable extends collection.IterableBase$(E) {
       WhereIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
@@ skipping 20 matching lines @@
         return false;
       }
       get current() {
         return this[_iterator].current;
       }
     }
     return WhereIterator;
   });
   let WhereIterator = WhereIterator$();
   let _ExpandFunction$ = dart.generic(function(S, T) {
-    class _ExpandFunction extends core.Function {}
+    let _ExpandFunction = dart.typedef('_ExpandFunction', () => dart.functionType(core.Iterable$(T), [S]));
     return _ExpandFunction;
   });
   let _ExpandFunction = _ExpandFunction$();
   let ExpandIterable$ = dart.generic(function(S, T) {
     class ExpandIterable extends collection.IterableBase$(T) {
       ExpandIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
       get [core.$iterator]() {
-        return new (ExpandIterator$(S, T))(this[_iterable][core.$iterator], dart.as(this[_f], dart.throw_("Unimplemented type (S) → Iterable<T>")));
+        return new (ExpandIterator$(S, T))(this[_iterable][core.$iterator], dart.as(this[_f], dart.functionType(core.Iterable$(T), [S])));

[Jennifer Messerly, 2015/04/09 18:44:28]

use functional ordering?

    dart.functionType(S, core.Iterable$(T))

so the type of `TResult foo(TArg0 arg0, TArg1 arg1` would be ]

    dart.functionType(TArg0, TArg1, TResult)

optional and named args are a little wacky, but those could be similar:

    dart.functionType(TArg0, [TArg1, TArg2], TResult)

    dart.functionType(TArg0, {arg1: TArg1, arg2: TArg2}, TResult)

[vsm, 2015/04/09 19:52:24]

In Dart source (e.g., typedefs, function params), the return type is first.  :-)

[Jennifer Messerly, 2015/04/10 00:57:18]

i mean, kind of, but not really. In a function declaration, yes. At use sites?
We don't have an expression form for creating function types. If we did, it
might very well follow Arg -> Return type order. I mean consider C#: Func<S, T>
is a function that accepts an S and returns T. Similar is C#'s equivalent of
`map`: list.select<T,R>(arg) // takes a T, returns an R ... ditto Guava for
Java:
http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/base...
... I don't recall that ever coming up as a point of confusion. Especially
nowadays with lambdas: (arg1, arg2) => myResult ... the ordering feels very
natural for programmers.

       }
     }
     return ExpandIterable;
   });
   let ExpandIterable = ExpandIterable$();
   let _currentExpansion = dart.JsSymbol('_currentExpansion');
   let _nextExpansion = dart.JsSymbol('_nextExpansion');
   let ExpandIterator$ = dart.generic(function(S, T) {
     class ExpandIterator extends core.Object {
       ExpandIterator(iterator$, f$) {
@@ skipping 94 matching lines @@
   });
   let TakeIterator = TakeIterator$();
   let TakeWhileIterable$ = dart.generic(function(E) {
     class TakeWhileIterable extends collection.IterableBase$(E) {
       TakeWhileIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
       get [core.$iterator]() {
-        return new (TakeWhileIterator$(E))(this[_iterable][core.$iterator], dart.as(this[_f], dart.throw_("Unimplemented type (E) → bool")));
+        return new (TakeWhileIterator$(E))(this[_iterable][core.$iterator], dart.as(this[_f], dart.functionType(core.bool, [E])));
       }
     }
     return TakeWhileIterable;
   });
   let TakeWhileIterable = TakeWhileIterable$();
   let _isFinished = dart.JsSymbol('_isFinished');
   let TakeWhileIterator$ = dart.generic(function(E) {
     class TakeWhileIterator extends core.Iterator$(E) {
       TakeWhileIterator(iterator$, f$) {
         this[_iterator] = iterator$;
@@ skipping 90 matching lines @@
   });
   let SkipIterator = SkipIterator$();
   let SkipWhileIterable$ = dart.generic(function(E) {
     class SkipWhileIterable extends collection.IterableBase$(E) {
       SkipWhileIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
       get [core.$iterator]() {
-        return new (SkipWhileIterator$(E))(this[_iterable][core.$iterator], dart.as(this[_f], dart.throw_("Unimplemented type (E) → bool")));
+        return new (SkipWhileIterator$(E))(this[_iterable][core.$iterator], dart.as(this[_f], dart.functionType(core.bool, [E])));
       }
     }
     return SkipWhileIterable;
   });
   let SkipWhileIterable = SkipWhileIterable$();
   let _hasSkipped = dart.JsSymbol('_hasSkipped');
   let SkipWhileIterator$ = dart.generic(function(E) {
     class SkipWhileIterator extends core.Iterator$(E) {
       SkipWhileIterator(iterator$, f$) {
         this[_iterator] = iterator$;
@@ skipping 314 matching lines @@
         } else {
           buffer.write(list[core.$get](0));
           for (let i = 1; dart.notNull(i) < dart.notNull(list[core.$length]); i = dart.notNull(i) + 1) {
             buffer.write(separator);
             buffer.write(list[core.$get](i));
           }
         }
         return buffer.toString();
       }
       where(iterable, f) {
-        return new (WhereIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(f, dart.throw_("Unimplemented type (T) → bool")));
+        return new (WhereIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(f, dart.functionType(core.bool, [T])));
       }
       static map(iterable, f) {
         return new MappedIterable(iterable, f);
       }
       static mapList(list, f) {
         return new MappedListIterable(list, f);
       }
       static expand(iterable, f) {
         return new ExpandIterable(iterable, f);
       }
       takeList(list, n) {
         return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), 0, n);
       }
       takeWhile(iterable, test) {
-        return new (TakeWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(test, dart.throw_("Unimplemented type (T) → bool")));
+        return new (TakeWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(test, dart.functionType(core.bool, [T])));
       }
       skipList(list, n) {
         return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), n, null);
       }
       skipWhile(iterable, test) {
-        return new (SkipWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(test, dart.throw_("Unimplemented type (T) → bool")));
+        return new (SkipWhileIterable$(T))(dart.as(iterable, core.Iterable$(T)), dart.as(test, dart.functionType(core.bool, [T])));
       }
       reversedList(list) {
         return new (ReversedListIterable$(T))(dart.as(list, core.Iterable$(T)));
       }
       static sortList(list, compare) {
         if (compare == null)
           compare = core.Comparable.compare;
         Sort.sort(list, compare);
       }
       static shuffleList(list, random) {
@@ skipping 814 matching lines @@
   exports.ReversedListIterable = ReversedListIterable;
   exports.UnmodifiableListError = UnmodifiableListError;
   exports.NonGrowableListError = NonGrowableListError;
   exports.makeListFixedLength = makeListFixedLength;
   exports.Lists = Lists;
   exports.printToConsole = printToConsole;
   exports.Sort = Sort;
   exports.Symbol = Symbol;
   exports.POWERS_OF_TEN = POWERS_OF_TEN;
 })(_internal || (_internal = {}));