Scala, repita una lista finita infinitamente

Question

Quiero usar la clase Stream en scala para repetir una lista dada infinitamente.

Por ejemplo, la lista (1,2,3,4,5) Quiero crear una secuencia que me da (1,2,3,4,5,1,2,3,4,5,1 , 2,3 ....)

Para que pueda ajustar la operación de toma. Sé que esto se puede implementar de otras maneras, pero quiero hacerlo de esta manera por alguna razón, solo me pones de humor :)

Así que la idea es que con este ciclo infinito creado a partir de alguna lista, pueda usar Take Operation, y cuando llega al final de la lista, se cicla.

¿Cómo hago una secuencia que simplemente repite una lista dada?

Answer 1

muy similar a la de @ Eastsun, pero un poco más intención reveladora. Probado en Scala 2.8.

scala> val l = List(1, 2, 3) 
l: List[Int] = List(1, 2, 3) 

scala> Stream.continually(l.toStream).flatten.take(10).toList 
res3: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2, 3, 1) 

Alternativamente, con Scalaz:

scala> import scalaz._ 
import scalaz._ 

scala> import Scalaz._ 
import Scalaz._ 

scala> val l = List(1, 2, 3) 
l: List[Int] = List(1, 2, 3) 

scala> l.toStream.repeat[Stream].join.take(10).toList 
res7: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2, 3, 1) 

Answer 2

robados blatently del excelente libro Scala by Example, capítulo 12, y con algunas modificaciones:

def repeatedSeq(idx: Int, lst:Seq[Int]): Stream[Int] = Stream.cons(lst(idx), repeatedSeq((idx + 1)%lst.length, lst)) 

for(i <- repeatedSeq(1,List(1,1,2,3,5))) println(i) 

Esto funciona para todos los tipos SEQ (a menos que no se pueden leer varias veces, por supuesto). Puede que no sea eficiente si la llamada .length es lenta. Probado en Scala 2.7.7.

Answer 3

Aquí es una implementación que no asumen que length es eficiente:

def rep[A](seq: Seq[A]) = { 
    def inner(proj: Seq[A]): Stream[A] = { 
    if (proj.isEmpty) 
     inner(seq) 
    else 
     Stream.cons(proj.first, inner(proj drop 1)) 
    } 

    if (seq.isEmpty) 
    Stream.empty 
    else 
    inner(seq) 
} 

Esto debería funcionar en un tiempo constante para cualquier Seq (incluyendo List o incluso Stream) y sólo impone una sobrecarga constante de tiempo para rellenar cada uno elemento. Además, funciona incluso para secuencias infinitas. Entonces, puede llamar al rep en un Stream infinito y el Stream resultante será equivalente a la entrada.

Answer 4

Hay una manera sencilla con la corriente # aplanan en Scala 2,8

Welcome to Scala version 2.8.0.r20542-b20100116020126 (Java HotSpot(TM) Client VM, Java 1.6.0_18). 
Type in expressions to have them evaluated. 
Type :help for more information. 

scala> def cycle[T](seq: Seq[T]) = Stream.from(0).flatten(_ => seq) 
cycle: [T](seq: Seq[T])scala.collection.immutable.Stream[T] 

scala> cycle(1::2::3::Nil) 
res0: scala.collection.immutable.Stream[Int] = Stream(1, ?) 

scala> res0.take(10) 
res1: scala.collection.immutable.Stream[Int] = Stream(1, ?) 

scala> res0.take(10).toList 
res2: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2, 3, 1) 

Answer 5

Un método alternativo es la concatenación de los .toStream de la entrada con sí mismo de forma recursiva. Es decir,

scala> val xs: Stream[Int] = List(1, 2, 3).toStream #::: xs 
xs: Stream[Int] = Stream(1, ?) 

scala> xs.take(10).toList 
res1: List[Int] = List(1, 2, 3, 1, 2, 3, 1, 2, 3, 1)