scala - generator/block to iterator/stream conversion -

Actually I want to change it:

  def data (block: T =  

In a stream (DataTostream is a work that makes this conversion):

  val data stream: stream [T] = DataTostream (data)  

I think this problem can be resolved continuously:

  // Assume that we do not know How the data applies / We just know (I & lt; - 0 to 10) B Lock (i)} // here we can print all data Intijrs data {i = & gt; Println (i)} // & gt; & Gt; But we really want to convert the data into the stream & lt; & Lt; // Very dumb solution is to collect all data in a list var dataList = List [Int] () data {i = & gt; DataList = i: dataList} // and make a stream from Data List.stream //, but we want to create a lazy, CPU, and memory efficient stream or want to make iterator from Data Variable Data stream: Stream [Int. ] = DataTostream (data) datastream .foreach {i = & gt; Println (i)} // And here a black magic continuity should be used // It is very hard for me to understand this magic / do anyone know what the datatostream function might look like?  

Thanks, David

Edit: To show an example Modified Traversable.view lazy

  scala> For deff data (F: int => unit) = (i & lt; - 1 to 10) {| Println ("generated" + i). F (I) | } Data: (F: (int) = Unit) Unit Scale & gt; Trouble [T] (function: (t => unit) = & gt; unit) = new traversal [t] {| Def foreach [X] (f: T => X) = func (f (_): unit). } TratraSable: [T] (Funk: (t) => Unit) => Unit) with java.lang.Object Traversable [T]  

Transcexual method Data function in one of your Traversal Collections. By itself, it's not anything bigger, but you can change it in a travelsview which is lazy. Here's an example:

  Scala> Brokenviewable (data) .view.take (3) .sum Generating 1 Generating 2 Generating 3 Generating 4 Race 1: Int = 6  

The unfortunate nature of the method is that it should go one The last value generated for working properly last, but it will end soon, the above code will appear without the ".View" call. However, here's a more compelling example:

  scala> Traceable (data) .view.take (2) .foreach (println) Generating 1 1 Generating 2 2 Generating 3  

So in the end, I believe that the collection you search for It is a traversal view, which is the easiest to create a view to create a traversal and then calls "view" if you actually wanted the stream type, then it is a method that is 2.8.0.final Works in and will "stream" without threads:

  scala> Def Datatostream (Data: (Int => Unit =)) = {| Val x = New Traversal [int] {| DRF Foracq [U] (F: Int => U) = {| Data (F): Unit. } | } | X.view.toList.toStream | } DataTostream: (Data: ((int (=) = Unit => Unit =) Scala.collection.immutable.Stream [Int] Scale & gt; DataToStream (data) res8: scala.collection.immutable.Stream [int] = stream (0,?)  

The unfortunate nature of this method is that it is completely It also means that all values ​​need to be buffer in memory, the only option is the support of the thread.

As one side: Skeleks. This was the motivating reason for choosing traversables as a direct return from IO. File method: "line" "characters" and "bytes".