Rewrite breakout

[MasseGuillaume]

seen in:
https://github.com/kxbmap/configs/pull/30/files#diff-8416f81bdac5bf53701680a5968a0f9eL226

input:

import scala.collection.breakOut
val map : Map[Int,String] = List("London", "France").map(x => (x.length, x))(breakOut)

output:

val map : Map[Int,String] = List("London", "France").map(x => (x.length, x)).toMap

[julienrf]

Well, the output is not semantically equivalent to the input since it creates an intermediate List.

[julienrf]

I think the rule should work as follows.

• Eligible methods are: map, flatMap, collect, ++, ++:, scanLeft, scanRight, zip and zipWithIndex,
• Any call of the form .<op>(collection.breakOut) (where <op> is a call of one of the aforementioned operations, e.g. map(f), zipWithIndex), should be replaced with .iterator.<op>.to(implicitly[Factory[<A>, <C>]]), where <A> and <C> are the two and third type parameters of the CanBuildFrom instance returned by collection.breakOut.

For instance, if one writes:

List(1, 2, 3).map(_ + 1)(collection.breakOut): Set[Int]

Which instantiates breakOut’s type parameters like so:

List(1, 2, 3).map(_ + 1)(collection.breakOut[List[Int], Int, Set[Int]]): Set[Int]

We should produce:

List(1, 2, 3).iterator.map(_ + 1).to(implicitly[Factory[Int, Set[Int]]])

[MasseGuillaume]

would this works too?

List(1, 2, 3).iterator.map(_ + 1).to(implicitly)

[julienrf]

You should just try:

Welcome to Scala 2.13.0-M4 (OpenJDK 64-Bit Server VM, Java 1.8.0_171).
Type in expressions for evaluation. Or try :help.

scala> List(1, 2, 3).iterator.map(_ + 1).to(implicitly): Set[Int]
res0: Set[Int] = ChampHashSet(2, 3, 4)

It seems to be working, yes!

[MasseGuillaume]

@julienrf I know, I mean does this work in the general case for migrations. The implicit Factory could be a bit different than the CanBuildFrom.

[julienrf]

It seems to be enough: the type of the required implicit Factory seems to be correctly inferred by the compiler based on the expected result type.

[MasseGuillaume]

@julienrf

val xs = List("London", "France")
def f(x: String): (Int, String) = (x.length, x)
val map = xs.iterator.map(f).to(implicitly)
val map2: Map[Int, String] = xs.iterator.map(f).to(implicitly)

10:35: type mismatch;
[error]  found   : Nothing <:< Nothing
[error]  required: scala.collection.Factory[(Int, String),?]
[error]   val map = xs.iterator.map(f).to(implicitly)
[error]                                   ^

[julienrf]

The line:

val map = xs.iterator.map(f).to(implicitly)

Is not representative of the way breakOut is supposed to be used: the result type must be known by the compiler rather than being inferred by a “default” CanBuildFrom instance.

Therefore I suggest ignoring that case for now.

[MasseGuillaume]

ok, we ignore the following:

import scala.collection.breakOut
val xs = List("London", "France")
def f(x: String): (Int, String) = (x.length, x)
val map = xs.map(f)(breakOut)
// map: scala.collection.immutable.IndexedSeq[(Int, String)] = Vector((6,London), (6,France))

[MasseGuillaume]

no solution

• dequeueAll (does not take an implicit Factory)
• Map.transform (does not take an implicit Factory)
• scan (should be deprecated ?)

view

• +:
• :+
• ++:
• updated

iterator

• padTo (bug: [2.13.0-M4] Implement missing methods for Iterator bug#10961)
• scanRight (bug: [2.13.0-M4] Implement missing methods for Iterator bug#10961)
• zipAll
• ++
• union (rewrite to a.concat(b))
• collect
• flatMap
• map
• scanLeft
• zip
• zipWithIndex

reverse-iterator

• reverseMap

[MasseGuillaume]

@julienrf

for operators that take collections such as ++ or zip, do we apply .iterator as well to the rhs ?

-lhs.zip(rhs)(breakOut): Array[(Int, Int)]
+lhs.iterator.zip(rhs.iterator).to(implicitly): Array[(Int, Int)]

[julienrf]

No.

[SethTisue]

List(1, 2, 3).iterator.map(_ + 1).to(implicitly)

ha, cool