Procedura consigliata per utilizzare la scala immutabile Coda

Question

Vorrei sapere come utilizzare la coda nel modo migliore. Ad esempio, mi piacerebbe deselezionare gli elementi e stamparli con una funzione ricorsiva. E vorrei la funzione più bella.

Ad esempio, questa è una funzione che esegue ciò che voglio. Ma non mi piace il se.

È un modo migliore di utilizzare la coda?

import scala.collection.immutable.Queue 

def printQ[A](p:Queue[A]) { 
    if(!p.isEmpty) { 
    p.dequeue match { 
     case (x,xs) => 
     println(x.toString) 
     printQ(xs) 
     case _ => 
     println("End")  
    } 
    }  
} 

printQ(Queue(1,2,4,5)) 

Grazie per le risposte.

Answer 1

Queue non dispone di un metodo dequeueOption, che renderebbe un po 'più bello. Tuttavia, nota che la prima voce della tua partita è completa; non puoi mai raggiungere il codice println("End"). Così si potrebbe migliorare la vostra versione:

def printQ[A](p: Queue[A]) { 
    if (!p.isEmpty) p.dequeue match { 
    case (x,xs) => 
     println(x.toString) 
     printQ(xs) 
    } 
} 

Naturalmente, poiché questo solo attraversa la coda in ordine, si può sempre e solo

p.foreach(println) 

per stampare tutto.

Answer 2

Non è necessario per verificare case _:

scala> @annotation.tailrec def printQ[A](p:Queue[A]) { 
    | if(!p.isEmpty) { 
    |  p.dequeue match { 
    |  case (x,xs) => 
    |   println(x.toString) 
    |   printQ(xs) 
    |  } 
    | } 
    | } 
printQ: [A](p: scala.collection.immutable.Queue[A])Unit 

scala> printQ(Queue(1,2,4,5)) 
1 
2 
4 
5 

E 'necessario per la funzione di essere ricorsiva?

scala> for (i <- Queue(1, 2, 4, 5)) println(i) 
1 
2 
4 
5