scala Vorwärts-Referenz erstreckt sich über Definition

Question

case object Empty extends Stream[Nothing] 
case class Cons[+A](h:() => A, t:() => Stream[A]) extends Stream[A] 

sealed trait Stream[+A] { 

    def toList: List[A] = { 
    val buf = new collection.mutable.ListBuffer[A] 
    def go(s: Stream[A]): List[A] = s match { 
     case Cons(h, t) => 
     buf += h() 
     go(t()) 
     case _ => buf.toList 
    } 
    go(this) 
    } 

    def cons[A](hd: => A, tl: => Stream[A]): Stream[A] = Stream.cons(hd, tl) 

    def empty = Stream.empty 

    def unfold[A, S](z: S)(f: S => Option[(A, S)]): Stream[A] = f(z) match { 
    case Some((h,t)) => cons(h, unfold(t)(f)) 
    case None => empty 
    } 

    def take(n: Int): Stream[A] = unfold((this, n)) { 
    case (Cons(h, t), 1) => Some((h(), (empty, 0))) 
    case (Cons(h, t), n) if n > 1 => Some((h(), (t(), n-1))) 
    case (Empty, 0) => None 
    } 
} 

object Stream { 

    def cons[A](hd: => A, tl: => Stream[A]): Stream[A] = Cons(() => hd,() => tl) 

    def empty[A]: Stream[A] = Empty 

    val ones: Stream[Int] = Stream.cons(1, ones) 
} 

object StreamTest { 
    def main(args: Array[String]) { 

    //why compile error: forward reference extends over definition of value ones 
    /*val ones: Stream[Int] = Stream.cons(1, ones) 
    println(ones.take(5).toList)*/ 

    println(Stream.ones.take(5).toList) 
    } 
} 

warum Kompilierungsfehler ?: Vorwärts-Referenz erstreckt sich über Definition von Wert diejenigen

in Paar Objekt 'Stream, val diejenigen: Strom [Int] = Stream.scons (1, ist) ist ok

aber in main-Methode, es ist nicht ok (aber ... gleiche Kunststoffe!)

Answer 1

Lokale Werte sind keine Mitglieder.

Für Ihren Test-Code, dies zu tun:

object StreamTest extends App { 
    //def main(args: Array[String]) { 

    //why compile error: forward reference extends over definition of value ones 
    val ones: Stream[Int] = Stream.cons(1, ones) 
    println(ones.take(5).toList) 

    println(Stream.ones.take(5).toList) 
    //} 
} 

Die Einschränkung in Blöcken in the spec here formuliert, wo die andere Beratung ist es eine faule val in dem Block zu machen, die die gleiche Wirkung hat.

Answer 2

Die Vorwärts-Referenz ist in Cons[+A]..., die in dieser Zeile verwiesen wird:

def cons[A](hd: => A, tl: => Stream[A]): Stream[A] = Cons(() => hd,() => tl) 

Try

case object Empty extends Stream[Nothing] 
case class Cons[+A](h:() => A, t:() => Stream[A]) extends Stream[A] 

in das Begleitobjekt zu bewegen.