s.c.m.Shrinkable#subtractAll could return early once `this` is known to be empty.

[joshlemer]

The scala.collection.mutable.Shrinkable[T] trait defines a method

  def subtractAll(xs: collection.IterableOnce[A]): this.type = {
    @tailrec def loop(xs: collection.LinearSeq[A]): Unit = {
      if (xs.nonEmpty) {
        subtractOne(xs.head)
        loop(xs.tail)
      }
    }
    xs match {
      case xs: collection.LinearSeq[A] => loop(xs)
      case xs => xs.iterator.foreach(subtractOne)
    }
    this
  }

however this could be optimized in the case where it is an Iterable that is implementing Shrinkable. In that case, after each removal, we could check if we are known to be empty (via knownSize or sizeCompare). If we are known empty, we can return early.

Does this warrant something like a trait IterableOptimizedShrinkable[T] extends Iterable[T] with Shrinkable[T]? I would say probably. From a quick look in the standard library, I think every single implementation of shrinkable is in fact an Iterable.

[julienrf]

I agree that we should experiment with such an optimization.

IIRC, it might not be possible or easy to unify Srinkable[A] and Iterable[A], because of Map[K, V], which extends Iterable[(K, V)] but Shrinkable[K].

[joshlemer]

@julienrf that isn't a problem, I was experimenting with it and just had to create a trait ShrinkableIterable[A, B] extends Iterable[A] with Shrinkable[B]

[NthPortal]

related: #12179