fake an unlimited sequence?

[HamsterofDeath]

is there a simple way to fake a sequence that returns the same object at
every index? i want to avoid streams since they would introduce a
memory-"leak" here....
access via index is a must have, otherwise i would just use an iterator.

thx :)

[√iktor Ҡlang]

sequence as in "Seq" or as in "Iterator"?

What would an infinite Seq return for size? What would "foreach" do?

Cheers,

√

--
Viktor Klang

Director of Engineering

Typesafe - The software stack for applications that scale

Twitter: @viktorklang

[HamsterofDeath]

foreach would just loop forever, and size would return Integer.MAX_VALUE

i could pass an iterator creating function instead of a seq, but the access via index would be pretty slow then.
to answer your question: sequence as in seq.

[√iktor Ҡlang]

Wow, that's a very toxic Seq. I'd recommend against going that road.

[HamsterofDeath]

there is a much better way:
(Int) => U

so obivous :D

[Seth Tisue]

On Thu, Dec 20, 2012 at 5:45 AM, HamsterofDeath <h-s...@gmx.de> wrote:
> is there a simple way to fake a sequence that returns the same object at
> every index? i want to avoid streams since they would introduce a
> memory-"leak" here....

A circular stream doesn't leak (so say the prophets).

Sadly, no method in the standard library will give us a circular
stream. Let's write one:

Welcome to Scala version 2.10.0-RC5

scala> def circular[T](xs: Stream[T]): Stream[T] = {
| lazy val knot: Stream[T] = xs #::: knot
| knot
| }
circular: [T](xs: Stream[T])Stream[T]

scala> circular(Stream(1)).take(10).mkString
res0: String = 1111111111

scala> circular(Stream.from(1).map{x => println(x); x}.take(3))
1
res1: Stream[Int] = Stream(1, ?)

scala> res1.take(12).mkString
2
3
res2: String = 123123123123

--
Seth Tisue | Northwestern University | http://tisue.net
developer, NetLogo: http://ccl.northwestern.edu/netlogo/

[HamsterofDeath]

+1 for the knot

[Alec Zorab]

It's somewhat surprising that Stream.continuously doesn't do that, but instead opts to allocate new cells as you iterate.

[HamsterofDeath]

i guess this happens to allow the passed element generator to behave like an iterator - it can generate different element every time

[Seth Tisue]

On Fri, Dec 21, 2012 at 10:00 AM, Alec Zorab <alec...@googlemail.com> wrote:
> It's somewhat surprising that Stream.continuously doesn't do that, but
> instead opts to allocate new cells as you iterate.

Oh, but that's useful too:
Stream.continually(util.Random.nextInt)
Stream.continually(in.readLine()).takeWhile(_ != null)

It's not an accident that both these examples involve side effects. If
the argument to continually was known to be referentially transparent,
then there wouldn't be any need to keep making new cells.

[Vlad Patryshev]

On Fri, Dec 21, 2012 at 7:00 AM, Alec Zorab <alec...@googlemail.com> wrote:

It's somewhat surprising that Stream.continuously doesn't do that, but instead opts to allocate new cells as you iterate.

Not what I see:

scala> val x = new Object
x: java.lang.Object = java.lang.Object@15db386

scala> Stream.continually(x) take 3 mkString ","
res7: String = java.lang.Object@15db386,java.lang.Object@15db386,java.lang.Object@15db386
 

[Luke Vilnis]

It has multiple pointers to the same object, but I don't think that means it isn't allocating new cons cells to hold those pointers.

[HamsterofDeath]

make it a def instead of a val and you will get a different object every time

[Vlad Patryshev]

There is a difference between def, lazy val and val, is not there?