mejor práctica para usar scala inmutable Queue

Question

Me gustaría saber cómo usar Queue de la mejor manera funcional. Por ejemplo, me gustaría dequear elementos e imprimirlos con una función recursiva. Y me gustaría la función más hermosa.

Por ejemplo, esta es una función que hace lo que quiero. Pero no me gusta el si.

¿Es su una mejor manera de usar cola?

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)) 

Gracias por la respuesta.

Answer 1

Queue no tiene un método dequeueOption, lo que haría un poco más agradable. Sin embargo, tenga en cuenta que la primera entrada en su partida es exhaustiva; no se puede llegar al código println("End"). Por lo que podría mejorar su versión:

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

Por supuesto, ya que esto sólo atraviesa la cola en orden, uno siempre puede

p.foreach(println) 

para imprimir todo.

Answer 2

No es necesario para la prueba de 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 

¿Es necesario que la función sea recursiva?

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