Sync* methods are too slow.

[lrhn]

I've been recommended not using a sync* function to generate an iterable in platform code because it is too slow.
We should not have a language feature that is so slow that you are better off not using it. Then we are better off not having it.
We should try to make sync* functions as efficient as a hand-coded iterator, or close to it.
(The VM might be able to run them on a separate stack, and avoid desugaring completely, which will make it as efficient as possible. Desugaring to a state-machine should be an optimizing compiler, not a simple translation.)

(I assume async* functions are slow too).

[mraleph]

Can you post example of the code in question (one you got a recommendation for)?

[lrhn]

A simple benchmark of (probably too) simplistic code shows that yield* is fairly efficient, but a loop of individual yield statements is only ~ half as fast as hand-written code (VM) and a quarter as fast in dart2js.

class Reiterator<T> implements Iterator<T> {a
  final Iterator<T> _source;
  T _current;
  Reiterator(this._source);
  T get current => _current;
  bool moveNext() {
    if (_source.moveNext()) {
      _current = _source.current;
      return true;
    }
    return false;
  }
}

class Reiterable<T> extends Iterable<T> {
  final Iterable<T> _source;
  Reiterable(this._source);
  Iterator<T> get iterator => new Reiterator<T>(_source.iterator);
}

Iterable<T> reiterate<T>(List<T> source) sync* {
  yield* source;
}

Iterable<T> reiterate2<T>(List<T> source) sync* {
  for (int i = 0; i < source.length; i++) {
    yield source[i];
  }
}

main() {
  var names = ["handwritten", "yield*", "yield loop"];
  var source = new List<int>.generate(256, (x) => x);
  source.iterator..moveNext()..current;
  var sw = new Stopwatch();
  sw.start();
  sw.stop();
  sw.reset();
  for (var i = 0; i < 5; i++) {
    var sources =
        [new Reiterable(source), reiterate(source), reiterate2(source)];
    for (var j = 0; j < sources.length; j++) {
      var it = sources[j];
      var e = 0;
      var c = 0;
      sw.start();
      do {
        var r = 0;
        for (var i in it) r += i;
        if (r != 255 * 256 ~/ 2) throw "Wat?";
        e = sw.elapsedMilliseconds;
        c ++;
      } while (e < 2000);
      sw.stop();
      sw.reset();
      print("${names[j]}: ${c/e} /ms");
    }
  }
}

[matanlurey]

We've found async, async*, and sync* are all noticeably slower (and negatively effect Dart2JS code-size) than hand-authored alternatives, unfortunately. I'm happy to share specific benchmarks.

If you're curious about what other language features hurt us, this is a non-exhaustive list:
https://github.com/dart-lang/angular/blob/master/doc/dart2js_style_guide.md

[kevmoo]

Related #57714

It'd be nice if these abstractions were cheaper...

[rakudrama]

@mraleph There are a few sync* Golem benchmarks under "Iteration".

[rrousselGit]

This poped up in a stackoveflow question https://stackoverflow.com/questions/56414263/async-patterns-in-flutter-dart-any-downsides-to-async-await-vs-raw-future-api

If you're curious about what other language features hurt us, this is a non-exhaustive list:
https://github.com/dart-lang/angular/blob/master/doc/dart2js_style_guide.md

The link is dead. Is it still relevant?