Utilizzo degli operatori di confronto nel sistema di corrispondenza dei modelli di Scala

È possibile abbinare un confronto utilizzando il sistema di corrispondenza dei modelli in Scala? Per esempio:

a match {
    case 10 => println("ten")
    case _ > 10 => println("greater than ten")
    case _ => println("less than ten")
}

La seconda dichiarazione del caso è illegale, ma vorrei essere in grado di specificare "quando a è maggiore di".

È possibile aggiungere una guardia, ovvero ifun'espressione booleana e dopo il modello:

a match {
    case 10 => println("ten")
    case x if x > 10 => println("greater than ten")
    case _ => println("less than ten")
}

Modifica: Nota che questo è più che superficialmente diverso dal mettere un if after the =>, perché un pattern non corrisponderà se la guardia non è vera.

Come non risposta allo spirito della domanda, che ha chiesto come incorporare i predicati in una clausola di abbinamento, in questo caso il predicato può essere preso in considerazione prima del match :

def assess(n: Int) {
  println(
    n compare 10 match {
      case 0 => "ten"
      case 1 => "greater than ten"
      case -1 => "less than ten"
    })
}

Ora, la documentazione perscala.math.Ordering.compare(T, T) promette solo che i risultati non uguali saranno maggiori o minori di zero . Java Comparable#compareTo(T)è specificato in modo simile a quello di Scala. Sembra essere convenzionale usare 1 e -1 per i valori positivi e negativi, rispettivamente, come fa l' implementazione attuale di Scala , ma non si può fare un tale presupposto senza un certo rischio che l'implementazione cambi da sotto.

Una soluzione che secondo me è molto più leggibile dell'aggiunta di protezioni:

(n compare 10).signum match {
    case -1 => "less than ten"
    case  0 => "ten"
    case  1 => "greater than ten"
}

Appunti:

• Ordered.comparerestituisce un numero intero negativo se questo è inferiore a quello, positivo se maggiore e 0se uguale.
• Int.signumcomprime l'uscita da comparea -1per un numero negativo (inferiore a 10), 1per positivo (maggiore di 10) o 0per zero (uguale a 10).

Mentre tutte le risposte precedenti e qui sotto rispondono perfettamente alla domanda originale, alcune informazioni aggiuntive possono essere trovate nella documentazione https://docs.scala-lang.org/tour/pattern-matching.html , ma non si adattavano al mio caso ma poiché questa risposta StackOverflow è il primo suggerimento in Google, vorrei pubblicare la mia risposta, che è un caso d'angolo della domanda precedente.
La mia domanda è:

• Come usare una guardia nell'espressione di corrispondenza con un argomento di una funzione?

Che può essere parafrasato:

• Come usare un'istruzione if nell'espressione di corrispondenza con un argomento di una funzione?

La risposta è il seguente esempio di codice:

    def drop[A](l: List[A], n: Int): List[A] = l match {
      case Nil => sys.error("drop on empty list")
      case xs if n <= 0 => xs
      case _ :: xs => drop(xs, n-1)
    }

link a scala fiddle: https://scalafiddle.io/sf/G37THif/2 come puoi vederecase xs if n <= 0 => xs istruzione è in grado di usare n (argomento di una funzione) con l'istruzione guard (if).

Spero che questo aiuti qualcuno come me.