Use more efficient implementation. Fix comment typos.

Author: lrhn

pkgs/collection/lib/src/iterable_extensions.dart

@@ -75,34 +75,37 @@ extension IterableExtension<T> on Iterable<T> {
   /// print([].separated(-1)); // ()
   ///
   /// print([1, 2, 3].separated(
-  ///   -1
+  ///   -1,
   ///   before: true,
   /// )); // (-1, 1, -1, 2, -1, 3)
   ///
   /// print([1].separated(
-  ///   -1
+  ///   -1,
   ///   before: true,
   ///   after: true,
   /// )); // (-1, 1, -1)
   ///
   /// print([].separated(
-  ///   -1
+  ///   -1,
   ///   before: true,
   ///   after: true,
   /// )); // ()
   /// ```
   Iterable<T> separated(T separator,
       {bool before = false, bool after = false}) sync* {
-    const emitBefore = 1;
-    const emitAfter = 2;
-    var state = before ? emitBefore : 0;
-    final afterState = emitBefore | (after ? emitAfter : 0);
-    for (var element in this) {
-      if (state & emitBefore != 0) yield separator;
-      state = afterState;
-      yield element;
+    var iterator = this.iterator;
+    if (iterator.moveNext()) {
+      if (before) yield separator;
+      while (true) {
+        yield iterator.current;
+        if (iterator.moveNext()) {
+          yield separator;
+        } else {
+          break;
+        }
+      }
+      if (after) yield separator;
     }
-    if (state & emitAfter != 0) yield separator;
   }
 
   /// Creates new list with the elements of this list separated by [separator].
@@ -124,32 +127,39 @@ extension IterableExtension<T> on Iterable<T> {
   /// print([].separatedList(-1)); // []
   ///
   /// print([1, 2, 3].separatedList(
-  ///   -1
+  ///   -1,
   ///   before: true,
   /// )); // [-1, 1, -1, 2, -1, 3]
   ///
   /// print([1].separatedList(
-  ///   -1
+  ///   -1,
   ///   before: true,
   ///   after: true,
   /// )); // [-1, 1, -1]
   ///
   /// print([].separatedList(
-  ///   -1
+  ///   -1,
   ///   before: true,
   ///   after: true,
   /// )); // []
   /// ```
   List<T> separatedList(T separator,
       {bool before = false, bool after = false}) {
-    var hasElement = false;
-    return [
-      for (var element in this) ...[
-        if (hasElement || (hasElement = true) && before) separator,
-        element,
-      ],
-      if (hasElement && after) separator
-    ];
+    var result = <T>[];
+    var iterator = this.iterator;
+    if (iterator.moveNext()) {
+      if (before) result.add(separator);
+      while (true) {
+        result.add(iterator.current);
+        if (iterator.moveNext()) {
+          result.add(separator);
+        } else {
+          break;
+        }
+      }
+      if (after) result.add(separator);
+    }
+    return result;
   }
 
   /// The elements that do not satisfy [test].

pkgs/collection/lib/src/list_extensions.dart

@@ -390,50 +390,58 @@ extension ListExtensions<E> on List<E> {
   ///
   /// Example:
   /// ```dart
-  /// print([1, 2, 3]..insertSeparator(-1)); // [1, -1, 2, -1, 3]
-  /// print([1]..insertSeparator(-1)); // [1]
-  /// print([]..insertSeparator(-1)); // []
+  /// print([1, 2, 3]..separate(-1)); // [1, -1, 2, -1, 3]
+  /// print([1]..separate(-1)); // [1]
+  /// print([]..separate(-1)); // []
   ///
-  /// print([1, 2, 3]..insertSeparator(
-  ///   -1
+  /// print([1, 2, 3]..separate(
+  ///   -1,
   ///   before: true,
   /// )); // [-1, 1, -1, 2, -1, 3]
   ///
-  /// print([1]..insertSeparator(
-  ///   -1
+  /// print([1]..separate(
+  ///   -1,
   ///   before: true,
   ///   after: true,
   /// )); // [-1, 1, -1]
   ///
-  /// print([]..insertSeparator(
-  ///   -1
+  /// print([]..separate(
+  ///   -1,
   ///   before: true,
   ///   after: true,
   /// )); // []
   /// ```
   void separate(E separator, {bool before = false, bool after = false}) {
     var length = this.length;
     if (length == 0) return;
-    var newLength = length * 2 - 1;
-    var offset = 0;
-    if (before) {
-      newLength++;
-      offset = 1;
+    // New position of first element.
+    var newFirst = before ? 1 : 0;
+    // New position of last element.
+    var newLast = length * 2 - (newFirst ^ 1);
+
+    var splitIndex = length - newFirst;
+    var cursor = splitIndex >> 1;
+    if (splitIndex.isEven) {
+      add(this[cursor]);
     }
-    if (after) newLength++;
-    E newElementAt(int index) {
-      index -= offset;
-      if (index.isOdd) return separator;
-      return this[index >> 1];
+    cursor++;
+    while (this.length < newLast) {
+      add(separator);
+      add(this[cursor++]);
     }
+    assert(cursor == length);
+    if (after) add(separator);
 
-    for (var i = length; i < newLength; i++) {
-      add(newElementAt(i));
+    cursor = splitIndex >> 1;
+    if (splitIndex.isOdd) {
+      this[--length] = this[cursor];
     }
-    for (var i = length, firstChanged = offset ^ 1; i > firstChanged;) {
-      --i;
-      this[i] = newElementAt(i);
+    cursor--;
+    for (var i = length; i > 1;) {
+      this[--i] = separator;
+      this[--i] = this[cursor--];
     }
+    if (newFirst != 0) this[0] = separator;
   }
 }
 

pkgs/collection/test/separate_extensions_test.dart

@@ -229,20 +229,39 @@ void main() {
       });
     });
     group('Multiple', () {
-      test('', () {
-        expect(<int>[1, 2, 3]..separate(42), [1, 42, 2, 42, 3]);
-      });
-      test('before', () {
-        expect(
-            <int>[1, 2, 3]..separate(42, before: true), [42, 1, 42, 2, 42, 3]);
-      });
-      test('after', () {
-        expect(
-            <int>[1, 2, 3]..separate(42, after: true), [1, 42, 2, 42, 3, 42]);
-      });
-      test('before and after', () {
-        expect(<int>[1, 2, 3]..separate(42, before: true, after: true),
-            [42, 1, 42, 2, 42, 3, 42]);
+      group('odd length', () {
+        test('', () {
+          expect(<int>[1, 2, 3]..separate(42), [1, 42, 2, 42, 3]);
+        });
+        test('before', () {
+          expect(<int>[1, 2, 3]..separate(42, before: true),
+              [42, 1, 42, 2, 42, 3]);
+        });
+        test('after', () {
+          expect(
+              <int>[1, 2, 3]..separate(42, after: true), [1, 42, 2, 42, 3, 42]);
+        });
+        test('before and after', () {
+          expect(<int>[1, 2, 3]..separate(42, before: true, after: true),
+              [42, 1, 42, 2, 42, 3, 42]);
+        });
+      });
+      group('even length', () {
+        test('', () {
+          expect(<int>[1, 2, 3, 4]..separate(42), [1, 42, 2, 42, 3, 42, 4]);
+        });
+        test('before', () {
+          expect(<int>[1, 2, 3, 4]..separate(42, before: true),
+              [42, 1, 42, 2, 42, 3, 42, 4]);
+        });
+        test('after', () {
+          expect(<int>[1, 2, 3, 4]..separate(42, after: true),
+              [1, 42, 2, 42, 3, 42, 4, 42]);
+        });
+        test('before and after', () {
+          expect(<int>[1, 2, 3, 4]..separate(42, before: true, after: true),
+              [42, 1, 42, 2, 42, 3, 42, 4, 42]);
+        });
       });
     });
     test('nulls', () {