Prevent Chain instances being backed by mutable or lazy Seq

[bplommer]

This addresses two issues:

• Changes Chain.Wrap to wrap immutable.Seq instead of Seq, which until 2.13 could be mutable.
• When converting from IterableOnce, explicitly convert to Vector. Previous use of .iterator.toSeq can return a lazy Seq, creating race conditions - in 2.12 it returns Stream. In 2.13 it returns List, but this isn't guaranteed by the return type.

I haven't attempted to prevent Chain from wrapping a LazyList or Stream passed directly to the constructor.

[satorg]

Just to clarify: what are the race conditions you mentioned?

[johnynek]

let's add a more complete comment here. I don't know the race conditions you are referring to, and future comment readers might also be confused.

I think toVector is fine even if there is no race conditions because Vector is very memory efficient (due to internally using Array).

[johnynek]

Thanks for taking this!

Nice safety fix.

[satorg]

Not an objection but rather just a suggestion about the style.

I personally don't like such renames on imports, because they tend to introduce new not-well known names. Moreover, Scala Docs suggests a convention about it:
https://docs.scala-lang.org/overviews/collections/overview.html

I.e. you could import it in this way:

import scala.collection.immutable
import scala.collection.mutable

Then use it in the code:

s match {
  case seq: mutable.Seq[A] => fromMutableSeq(mut)
  case seq: immutable.Seq[A]  => fromImmutableSeq(imm)
}

That looks way clearer and easier to read, doesn't it?

[armanbilge]

Yup, I very much feel the same way about this.

[satorg]

This implementation is identical in both Scala 2.12 and 2.13+ versions. I wonder – does it make sense to make it shared to avoid unnecessary duplication?

[armanbilge]

Eh, I don't think it's worth the mental indirection when reading the code. It's just a few lines, it's fine.

[johnynek]

actually, Seq isn't sealed, so in principle there could be other subclasses.

Can we instead do:

s match {
  case imm: ImSeq[A] => fromImmutableSeq(imm)
  case _ =>
    if (s.isEmpty) Empty
    else if (s.lengthCompare(1) == 0) Singleton(s.head)
    else Wrap(s.toVector)
}

[armanbilge]

@bplommer polite bump, seems just a few fixes and then this is mergeable :) thanks!

[bplommer]

@bplommer polite bump, seems just a few fixes and then this is mergeable :) thanks!

Completely forgot about this! Will do soon :)