Iterable pattern

[rrousselGit]

TL;DR: Dart lacks some way to do pattern matching on Iterable directly

When we use Iterables without transforming said Iterable into a List/Set/... (such as to avoid allocating a large collection), we end-up lacking a mean to use pattern matching.
Could we maybe have some Iterable-specific way to express a pattern match?

We could imagine #(a, b, c) as syntax for such pattern:

final list = [1, 2, 3];
final iterable = list.where((e) => e.isOdd);

switch (iterable) {
  case #(1, 3):
}

Or course, the token used could be anything else. Like #[], or not even use #.
Relying on () makes sense to me because Iterable.toString() uses (). But of course, this (1, 2) is taken by Record patterns.

Bonus:

• Support #(1, 2, ...)
• Support #(1, 2, ...final other) where other is an Iterable

[lrhn]

You shouldn't iterate an Iterable more than once.

It's possible that a pattern match can satisfy that by keeping an iterator and all previously seen values in its internal state, the same way out does for lists. It will effectively create a list of the elements as they are tested. But list patterns also cache all values they test, so that's not new.

You can almost get the same effect by having an unmodifiable LazyList class that builds itself from an iterator when it's accessed. If you never access above index n, it will only iterate to that. (Reading length will immediately read the entire iterable and build the complete list.)
Then you could have an extension getters .eagerList and .lazyList to convert an iterable to a to list, and you can use them in patterns as
Iterable(lazyList: list-pattern)

Except that list patterns do .length>n all the time to avoid access errors. If lists had a hasIndex(n), then it could see what the length of used for, instead of having to give the full length to someone who only needs to know if it's greater than 2, just like isNotEmpty is used instead of .length > 0. Too bad.