Как легко преобразовать IndexedSeq [Array [Int]] в Seq [Seq [Int]] в Scala?

Question

У меня есть функция, которая принимает список списков целых чисел, в частности Seq[Seq[Int]]. Затем я беру эти данные из чтения текстового файла и используя split, и который создает список Array. Это не признано Scala, которое вызывает ошибку совпадения. Но либо IndexedSeq, либо Array остались в порядке с функцией Seq[Int], видимо, только вложенная коллекция является проблемой. Как я могу конвертировать неявно IndexedSeq[Array[Int]] в Seq[Seq[Int]], или как еще я могу это сделать, кроме как использовать toList, как показано ниже? Например, Iterable[Iterable[Int]] кажется прекрасным, но я не могу это использовать.

scala> def g(x:Seq[Int]) = x.sum 
g: (x: Seq[Int])Int 

scala> g("1 2 3".split(" ").map(_.toInt)) 
res6: Int = 6 

scala> def f(x:Seq[Seq[Int]]) = x.map(_.sum).sum 
f: (x: Seq[Seq[Int]])Int 

scala> f(List("1 2 3", "3 4 5").map(_.split(" ").map(_.toInt))) 
<console>:9: error: type mismatch; 
found : List[Array[Int]] 
required: Seq[Seq[Int]] 
       f(List("1 2 3", "3 4 5").map(_.split(" ").map(_.toInt))) 
             ^

scala> f(List("1 2 3", "3 4 5").map(_.split(" ").map(_.toInt).toList)) 
res8: Int = 18 

Answer 1

Проблема заключается в том, что Array не реализует SeqLike. Обычно неявные преобразования в ArrayOps или WrappedArray, определенные в scala.predef, позволяют использовать массив точно так же, как Seq. Однако в вашем случае массив «скрыт» от неявных преобразований как общий аргумент. Одним из решений было бы намекнуть компилятор, который вы можете применить неявное преобразование в общий аргумент, как это:

def f[C <% Seq[Int]](x:Seq[C]) = x.map(_.sum).sum 

Это похоже на ответ Павла выше. Проблема заключается в том, что ограничения зрения устарели в Scala 2.11, и использование устаревших языковых функций не является хорошей идеей.К счастью, вид оценки можно переписать в виде контекстных границ следующим образом:

def f[C](x:Seq[C])(implicit conv: C => Seq[Int]) = x.map(_.sum).sum 

Теперь, это предполагает, что существует неявное преобразование из C в Seq[Int], который действительно присутствует в predef.

Answer 2

Как об этом:

implicit def _convert(b:List[Array[Int]]):Seq[Seq[Int]]=b.map(_.toList) 

Answer 3

Redefine е, чтобы быть немного более гибким.

С Traversable является родительским элементом List, Seq, Array и т. Д., F будет совместим с этими контейнерами, если он основан на Traversable. Traversable имеет сумму, сглаживание и карту, и это все, что нужно.

Что сложно об этом заключается в том, что

def f(y:Traversable[Traversable[Int]]):Int = y.flatten.sum 

является привередлив и не работает на ау типе List[Array[Int]] хотя он будет работать на Array[List[Int]]

Чтобы сделать его менее привередлив, некоторый тип вида оценки будет работать.

Первоначально я заменил вашу сумму сумм на операцию сплющивания/суммы.

def f[Y<%Traversable[K],K<%Traversable[Int]](y:Y):Int=y.flatten.sum 

Я нашел это также, кажется, работает, но я не проверял, как много:

def f[Y <% Traversable[K], K <% Traversable[Int]](y:Y):Int=y.map(_.sum).sum 

Этого <% синтаксис говорит Y является viewable, как проходимый [K] для некоторого типа K, который можно просмотреть в виде Пересечение Int.

Определите несколько различных контейнеров, в том числе и вам нужно:

scala> val myListOfArray = List(Array(1,2,3),Array(3,4,5)) 
val myListOfArray = List(Array(1,2,3),Array(3,4,5)) 
myListOfArray: List[Array[Int]] = List(Array(1, 2, 3), Array(3, 4, 5)) 

scala> val myArrayOfList = Array(List(1,2,3),List(3,4,5)) 
val myArrayOfList = Array(List(1,2,3),List(3,4,5)) 
myArrayOfList: Array[List[Int]] = Array(List(1, 2, 3), List(3, 4, 5)) 

scala> val myListOfList = List(List(1,2,3),List(3,4,5)) 
val myListOfList = List(List(1,2,3),List(3,4,5)) 
myListOfList: List[List[Int]] = List(List(1, 2, 3), List(3, 4, 5)) 

scala> val myListOfRange = List(1 to 3, 3 to 5) 
val myListOfRange = List(1 to 3, 3 to 5) 
myListOfRange: List[scala.collection.immutable.Range.Inclusive] = List(Range(1, 2, 3), Range(3, 4, 5)) 

Тест:

scala> f(myListOfArray) 
f(myListOfArray) 
res24: Int = 18 

scala> f(myArrayOfList) 
f(myArrayOfList) 
res25: Int = 18 

scala> f(myListOfList) 
f(myListOfList) 
res26: Int = 18 

scala> f(myListOfRange) 
f(myListOfRange) 
res28: Int = 18