Pour la boucle dans scala sans séquence?

Ainsi, tout en travaillant mon chemin à travers la "Scala pour l'Impatient" je me demandais: Peut-on utiliser un Scala pour boucle sans une séquence?

Par exemple, il y a un exercice dans le livre qui vous demande de construire un compteur objet qui ne peut pas être incrémenté dernières Entier.MAX_VALUE. Afin de tester ma solution, j'ai écrit le code suivant:

var c = new Counter
for( i <- 0 to Integer.MAX_VALUE ) c.increment()

Cela déclenche une erreur: les séquences ne peuvent contenir plus de Int.MaxValue éléments.
Il me semble que cela signifie que la Scala est d'abord de répartir et de remplissage d'un objet séquence, avec les valeurs de 0 à Entier.MaxValue, et ensuite de faire une boucle foreach sur cet objet séquence.

Je me rends compte que je pouvais faire ceci à la place:

var c = new Counter
while(c.value < Integer.MAX_VALUE ) c.increment()

Mais est-il une façon de faire traditionnelle de style C pour la boucle avec l'instruction for?

InformationsquelleAutor Adam Ness | 2011-09-08
  1. 18

    En fait, 0 to N ne pas le remplir quoi que ce soit avec des nombres entiers de 0 à N. Il crée plutôt une instance de scala.collection.immutable.Range, qui applique ses méthodes pour tous les entiers générés à la volée.

    L'erreur que vous avez couru dans est uniquement parce que vous devez être en mesure d'adapter le nombre d'éléments (s'ils existent réellement ou pas) dans la partie positive de l' Int afin de maintenir le contrat pour la length méthode. 1 to Int.MaxValue fonctionne très bien, comme le fait 0 until Int.MaxValue. Et le dernier est ce que votre boucle while est en train de faire de toute façon (to comprend le droit d'extrémité, until omet-il).

    De toute façon, depuis la Scala for est très différent (beaucoup plus générique) créature que le C for, la réponse courte est non, vous ne pouvez pas faire exactement la même chose. Mais vous pouvez probablement faire ce que vous voulez avec for (mais peut-être pas aussi vite que vous le souhaitez, car il est certains de la performance).

    InformationsquelleAutor Rex Kerr
  2. 6

    Wow, quelques belles réponses techniques pour une simple question (ce qui est bon!) Mais au cas où quelqu'un est à la recherche d'une réponse simple:

    //start from 0, stop at 9 inclusive
for (i <- 0 until 10){
    println("Hi " + i)
}

//or start from 0, stop at 9 inclusive
for (i <- 0 to 9){
    println("Hi " + i)
}

    Que Rex a souligné, "à" comprend le droit d'extrémité, "jusqu'à ce que" omet-il.

    InformationsquelleAutor user85116
  3. 4

    Oui et non, tout dépend de ce que vous demandez. Si vous vous demandez si vous pouvez parcourir une séquence d'entiers sans avoir à créer de la séquence en premier, alors oui vous pouvez, par exemple à l'aide de flux:

    def fromTo(from : Int, to : Int) : Stream[Int] = 
  if(from > to) {
    Stream.empty
  } else {
    //println("one more.") //uncomment to see when it is called
    Stream.cons(from, fromTo(from + 1, to))
  }

    Alors:

    for(i <- fromTo(0, 5)) println(i)

    De la rédaction de votre propre itérateur en définissant hasNext et la prochaine est une autre option.

    Si vous vous demandez si vous pouvez utiliser le 'pour' la syntaxe pour écrire un "natif" de la boucle, c'est à dire une boucle qui fonctionne par incrémentation de certains indigènes entier plutôt que d'itération sur les valeurs produites par une instance d'un objet, alors la réponse est, autant que je sache, non. Comme vous le savez peut-être, "pour" compréhensions sont sucre syntaxique pour une combinaison d'appels à flatMap, de filtre, d'une carte et/ou foreach (tous définis dans le FilterMonadic trait), en fonction de la nidification de générateurs et de leurs types. Vous pouvez essayer de compiler certains boucle et imprimer sa représentation intermédiaire du compilateur avec

    scalac -Xprint:refchecks

    pour voir comment ils sont développés.

    • Wow, difficile de répondre, mais un bon. Je suis juste l'apprentissage de la Scala, de sorte que vous avez utilisé beaucoup de termes que je ne suis qu'à peine familier avec, mais merci.
    • La définition de fromTo peut encore être simplifiée par l'utilisation de la méthode iterate sur le Stream (ou Iterator) compagnon de l'objet. Quelque chose le long des lignes de: def fromTo(from: Int, to: Int) = Stream.iterate(from, to - from)(_ + 1). Mais à l'aide de from until to est plus idiomatique et réalise la même chose.
    InformationsquelleAutor Philippe
  4. 2

    Il y a un tas de ces là-bas, mais je ne peux pas être dérangé googler pour le moment. La suite est assez canonique:

    @scala.annotation.tailrec
def loop(from: Int, until: Int)(f: Int => Unit): Unit = {
  if (from < until) {
    f(from)
    loop(from + 1, until)(f)
  }
}

loop(0, 10) { i =>
  println("Hi " + i)
}
    InformationsquelleAutor Derek Wyatt