.with alternativa en scala

Question

Vengo de Groovy y tiene un método .with en cada tipo que acepta un cierre de argumento único; el argumento es el objeto sobre el que se llama el método .with. Esto permite una técnica muy buena para extender las capacidades de encadenamiento funcional, lo que lo libera de la obligación de introducir variables temporales, factores su código, hace que sea más fácil de leer y hace otras sutilezas.

Quiero ser capaz de hacer algo como esto:

Seq(1, 2, 3, 4, 5) 
    .filter(_ % 2 == 0) 
    .with(it => if (!it.isEmpty) println(it)) 

En lugar de

val yetAnotherMeaninglessNameForTemporaryVariable = 
    Seq(1, 2, 3, 4, 5).filter(_ % 2 == 0) 
if (!yetAnotherMeaninglessNameForTemporaryVariable.isEmpty) 
    println(yetAnotherMeaninglessNameForTemporaryVariable) 

En otras palabras, en el primer ejemplo, el .with es un poco similar a .foreach pero en lugar de iterar a través los elementos del objeto al que se está llamando una vez en el objeto mismo. Entonces it es igual a Seq(1, 2, 3, 4, 5).filter(_ % 2 == 0).

Desde que era muy sorprendido no encontrar nada parecido en Scala, mis preguntas son:

• me estoy perdiendo algo?
• ¿hay alguna técnica alternativa nativa de Scala?
• si no, ¿hay algún motivo de peso por el que esta característica no esté implementada en Scala?

Actualización: una solicitud de función apropiada ha sido publicado en el seguimiento de incidencias Scala: https://issues.scala-lang.org/browse/SI-5324. Por favor vote y promocione

Answer 1

No existe ningún método de este tipo en la biblioteca estándar, pero no es difícil definir el suyo.

implicit def aW[A](a: A) = new AW(a) 
class AW[A](a: A) { 
    def tap[U](f: A => U): A = { 
    f(a) 
    a 
    } 
} 

val seq = Seq(2, 3, 11). 
      map(_ * 3).tap(x => println("After mapping: " + x)). 
      filter(_ % 2 != 0).tap(x => println("After filtering: " + x)) 

EDIT: (en respuesta al comentario)

Oh, no he entendido bien. Lo que necesitas está allí en la biblioteca de Scalaz. Viene con el nombre |> (denominado operador de tuberías). Con eso, su ejemplo se vería como se muestra a continuación:

Seq(1, 2, 3, 4, 5).filter(_ % 2 == 0) |> { it => if(!it.isEmpty) println(it) } 

Si no puede utilizar Scalaz, se puede definir el operador en su propia:

implicit def aW[A](a: A) = new AW(a) 
class AW[A](a: A) { 
    def |>[B](f: A => B): B = f(a) 
} 

Y no es una mala práctica para chulo método útil (s) en tipos existentes.Debe usar conversiones implícitas con moderación, pero creo que estos dos combinadores son lo suficientemente comunes para que sus proxenetas sean justificables.

Answer 2

Recuerde llamar por su nombre? Tal vez le da la capablity desea:

object Test { 
def main(args: Array[String]) { 
    delayed(time()); 
} 

def time() = { 
    println("Getting time in nano seconds") 
    System.nanoTime 
} 

def delayed(t: => Long) = { 
    println("In delayed method") 
    println("Param: " + t) 
    t 
} 
} 

como se describe en http://www.tutorialspoint.com/scala/functions_call_by_name.htm

Answer 3

algo Trate de esta manera.

println(Seq(1, 2, 3, 4, 5).filter(_ % 2 == 0).ensuring(!_.isEmpty)) 

Lanza una excepción de aserción si la condición no se cumple.

Answer 4

Existe cierta sintaxis para este patrón incluido en Scala:

Seq(1, 2, 3, 4, 5).filter(_ % 2 == 0) match { case it => if (!it.isEmpty) println(it) } 

Sin embargo, esto no es un idioma aceptado por lo que tal vez debe abstenerse de (ab) uso de ella.

Si no le gusta inventar y de montones de nombres para las variables ficticias, recuerde que puede utilizar alcance corchetes:

val importantResult = { 
    val it = Seq(1,2,3).filter(_ % 2 == 0) 
    if (!it.isEmpty) println(it) 
    it 
} 

val otherImportantResultWithASpeakingVariableName = { 
    val it = // ... 
    /* ... */ 
    it 
} 

Answer 5

Aunque me gusta otras soluciones mejores (ya que son más local y por lo tanto más fácil de seguir) , no olvide que puede

{ val x = Seq(1,2,3,4,5).filter(_ % 2 == 0); println(x); x } 

para evitar conflictos de nombres de las variables sin sentido y mantenerlos constreñido al ámbito apropiado.

Answer 6

Esto es sólo función de aplicación f(x) vuelta en su cabeza: x.with(f) ... Si usted está buscando una manera de hacer idiomática with en Scala, un-darle la vuelta:

(it => if (!it.isEmpty) println(it)) (Seq(1, 2, 3, 4, 5).filter(_ % 2 == 0)) 

Del mismo modo, si usted quiere x.with(f).with(g), solo use g(f(x)) ...