Streams in Scala

Question

Ich habe ein Stück Code, der eine Serie ist die Berechnung:

object Problem7 extends App { 
    lazy val ps: Stream[Int] = 2 #:: Stream.from(3).filter(i => 
    ps.takeWhile(j => j * j <= i).forall(i % _ > 0)) 

    val r = ps(10000) 
    println(r) 
} 

hier ps ist vom Typ Sammel-Stream, die tatsächlich eine Variable ist, sondern wie sein mögliches es zu nennen wie diese ps(10000) als nicht jede Methode und ich habe auch noch einen Ausdruck val fs:Stream[Int] = 0 #:: fs.scanLeft(1)(_ + _), hier auch bin ich ein wenig mehrdeutig darüber, wie wir fs.scanLeft(1)(_+_) in der Variablen selbst aufrufen.Einige Hilfe !!

Answer 1

hier ps ist vom Typ Sammel-Stream, die tatsächlich eine Variable ist aber wie sein mögliches es zu nennen wie diese ps (10000) als nicht jede Methode

Es ist möglich, ps(10000) weil Stream zu nennen hat eine apply Methode (geerbt von LinerSeqOptimized):

/** Selects an element by its index in the $coll. 
* Note: the execution of `apply` may take time proportial to the index value. 
* @throws `IndexOutOfBoundsException` if `idx` does not satisfy `0 <= idx < length`. 
*/ 
def apply(n: Int): A = { 
    val rest = drop(n) 
    if (n < 0 || rest.isEmpty) throw new IndexOutOfBoundsException("" + n) 
    rest.head 
} 

() auf jedem Objekt aufrufen in Scala lässt den Compiler nach einer apply Methode auf dem Objekt suchen. Dies ist vergleichbar mit der Möglichkeit, Fallklassen ohne das Schlüsselwort new zu instanziieren, da der Compiler automatisch apply und unapply für Sie generiert.

Wenn wir ein einfacheres reproduce aussehen werden:

def main(args: Array[String]): Unit = { 
    val ps: Stream[Int] = Stream.from(1, 1) 
    val r = ps(1) 
    println(r) 
} 

Der Compiler tatsächlich tut:

val r = ps.apply(1) 

Wo apply für eine Sammlung in der Regel das Element am Index nachschlägt i:

scala> val ps: Stream[Int] = Stream.from(1, 1) 
ps: Stream[Int] = Stream(1, ?) 

scala> val r = ps(1) 
r: Int = 2 

scala> val x = ps.apply(1) 
x: Int = 2 

Wenn Sie tatsächlich sehen wollen, was die comp Iler erzeugt:

object Problem7 extends Object { 
    def main(args: Array[String]): Unit = { 
     val ps: scala.collection.immutable.Stream = scala.`package`.Stream().from(1, 1); 
     val r: Int = scala.Int.unbox(ps.apply(1)); 
     scala.this.Predef.println(scala.Int.box(r)) 
    }; 

    def <init>(): Problem7.type = { 
     Problem7.super.<init>(); 
    () 
    } 
    } 
} 

Answer 2

Für den zweiten Teil der Frage,

lazy val fs:Stream[Int] = 0 #:: fs.scanLeft(1)(_ + _) 

Die # :: ist cons Operator Stream.cons zum Konstruieren Strömen verwendet. Der Parameter ConsWrapper ist ein by-name-Parameter und wird daher träge ausgewertet.

Es ist daher zulässig, fs nach dem Operator # :: zu referenzieren. Ich denke, wir müssen das Val zu Lazy Val ändern, sonst wirft der Scala-Compiler die Referenz über die Definition des Wertes fs hinaus.