[ACCEPTED]-Scala, repeat a finite list infinitely-infinite

Accepted answer

Score: 42

Very similar to @Eastsun's, but a bit more 2 intention revealing. Tested in 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)

Alternatively, with 1 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)

Score: 33

An alternative method is concatenating the 2 .toStream of the input with itself recursively. That 1 is,

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

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

Score: 8

There is a simple way with Stream#flatten 1 in 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)

Score: 5

Here's an implementation which doesn't assume 7 that length is efficient:

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)
}

This should run in constant 6 time for any Seq (including List or even Stream) and 5 only imposes a constant time overhead to 4 populate each element. Also, it works even 3 for infinite sequences. So, you can call 2 rep on an infinite Stream and the resulting Stream will 1 be equivalent to the input.

Score: 1

Stolen blatently from the excellent Scala by Example book, chapter 5 12, and with a few modifications:

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)

This works 4 for all Seq types (unless they can't be 3 read from multiple times, of course). Might 2 not be efficient if the .length call is 1 slow. Tested in Scala 2.7.7.

Source: stackoverflow.com

[ACCEPTED]-Scala, repeat a finite list infinitely-infinite

aggrid server side paging 'cannot get grid to draw rows when it is in the middle of drawing rows'

Treating an SQL ResultSet like a Scala Stream

Read content of RAR files using C#

Setting the internal buffer used by a standard stream (pubsetbuf)

How to copy binary data from one stream to another?

Write Unicode String In a File Using StreamWriter doesn't Work

How to skip bytes in a Stream

Does YouTube stream Videos via TCP?

Using System.IO.Pipelines together with Stream

WebRTC: how to detect when a stream or track gets removed from a PeerConnection, in Firefox?