.con alternativa in scala

Question

Provengo da Groovy e ha un metodo .with su ogni tipo che accetta una chiusura a singolo argomento; l'argomento è l'oggetto su cui viene chiamato il metodo .with. Ciò consente una tecnica molto interessante di estendere le funzionalità di concatenamento funzionale, che ti libera dall'obbligo di introdurre variabili temporanee, influisce sul tuo codice, rende più facile la lettura e altre sottigliezze.

Voglio essere in grado di fare qualcosa del genere:

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

Invece di

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

In altre parole il primo esempio del .with è un pò simile a .foreach ma invece di iterazione attraverso gli oggetti dell'oggetto che viene chiamato una volta sull'oggetto stesso. Quindi it equivale a Seq(1, 2, 3, 4, 5).filter(_ % 2 == 0).

Fin da quando ero molto sorpreso di non trovare niente di simile a Scala, le mie domande sono:

• mi sto perdendo qualcosa?
• esistono tecniche alternative native per Scala?
• in caso contrario, ci sono motivi validi per cui questa funzione non è implementata in Scala?

Aggiornamento: Una richiesta di funzionalità appropriata è stata pubblicata sulla questione inseguitore Scala: https://issues.scala-lang.org/browse/SI-5324. Si prega di votare e promuovere

Answer 1

Non esiste alcun metodo nella libreria standard, ma non è difficile definirlo.

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: (in risposta al commento)

Oh, ho capito male. Ciò di cui hai bisogno è nella biblioteca di Scalaz. Viene indicato con il nome |> (indicato come operatore di condotte). Con questo, il vostro esempio sarà simile illustrato di seguito:

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

Se non è possibile utilizzare Scalaz, è possibile definire l'operatore da soli:

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

E non è una cattiva pratica di magnaccia metodo utile (s) su tipi esistenti.Dovresti usare le conversioni implicite con parsimonia, ma penso che questi due combinatori siano abbastanza comuni da giustificare i loro protettori.

Answer 2

Ricordare la chiamata per nome? Forse ti dà la capablity si desidera:

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

come descritto nella http://www.tutorialspoint.com/scala/functions_call_by_name.htm

Answer 3

Prova sth come questo.

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

Genera un'eccezione di asserzione se la condizione non è soddisfatta.

Answer 4

V'è una certa sintassi di questo modello incluso nella Scala:

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

Tuttavia, questo non è un linguaggio accettato così si dovrebbe forse astenersi da (ab) utilizzarlo.

Se non ti piace inventare carichi e carichi di nomi per variabili dummy, ricordate che è possibile utilizzare ambito Bretelle:

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

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

Answer 5

Anche se mi piace altre soluzioni migliori (in quanto sono più locali e quindi più facile da seguire) , non dimenticare che è possibile

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

evitare collisioni di nome sulle variabili senza significato e mantenerle vincolate all'ambito appropriato.

Answer 6

Questo è solo funzione di applicazione f(x) rovesciato sul suo capo: x.with(f) ... Se siete alla ricerca di un modo di fare idiomatica with a Scala, un-flip:

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

Allo stesso modo, se voglio x.with(f).with(g), usa solo g(f(x)) ...