Est-ce une règle que l'application retournera toujours une option?

Question

J'ai essayé de créer une méthode unapply à utiliser dans la correspondance de modèle, et j'ai essayé de lui faire retourner quelque chose de différent que Option, mais Eclipse le montre comme une erreur. Est-ce une règle que unapply doit retourner un Option[T]?

EDIT: voici le code que j'essaie d'utiliser. Je suis passé le code de la section précédente de sorte que unapply retourne un

booléenne

import java.util.regex._ 

object NumberMatcher { 
    def apply(x:String):Boolean = { 
    val pat = Pattern.compile("\\d+") 
    val matcher = pat.matcher(x) 
    return matcher.find 
    } 

    def unapply(x:String):Boolean = { 
    val pat = Pattern.compile("\\d+") 
    val matcher = pat.matcher(x) 
    return matcher.find 
    } 
} 

object x { 
    def main(args : Array[String]) : Unit = { 
    val strings = List("geo12","neo493","leo") 
    for(val str <- strings) { 
     str match { 
     case NumberMatcher(group) => println(group) 
     case _ => println ("no") 
     } 
    } 
    } 
} 

Eclipse dit wrong number of arguments for object NumberMatcher. Pourquoi donc?

Answer 1

Si vous voulez retourner quelque chose avec unapply, retournez-le à Some. Renvoyer Boolean juste des tests si la correspondance peut être faite ou non.

Voici comment une correspondance de motif est traduit:

str match { 
    case NumberMatcher(group) => println(group) 
    case _ => println("no") 
} 

En supposant NumberMatcher rendements Option[...], il fera:

val r1 = NumberMatcher.unapply(str) 
if (r1 != None) { 
    val group = r1.get 
    println(group) 
} else { 
    println("no") 
} 

Si NumberMatcher retourne un booléen, alors vous pouvez avoir reçu quelque chose. Dans ce cas, ce qui arrive:

str match { 
    case NumberMatcher() => println("yes") 
    case _ => println("no") 
} 

devient

val r1 = NumberMatcher.unapply(str) 
if (r1) { 
    println("yes") 
} else { 
    println("no") 
} 

Notez que ceci est une explication très superficielle . Les correspondances de cas peuvent tester des constantes, avoir des conditions de protection supplémentaires, des alternatives, utiliser unapply de manière récursive, utiliser unapplySeq, etc. Ici, je montre seulement une utilisation très basique pour répondre à une question spécifique. Je conseille fortement de chercher une explication plus complète de la correspondance de modèle.

Answer 2

Regardez à nouveau ce example. je cite

Le type de retour d'un unapply doit être choisi comme suit:
* S'il est juste un test, un retour booléenne. Par exemple case even()
* S'il renvoie une seule sous-valeur de type T, renvoyer une option [T]
* Si vous souhaitez renvoyer plusieurs sous-valeurs T1, ..., Tn, regroupez-les dans une option de tuple optionnelle [(T1, ..., Tn)].

Answer 3

Lorsque vous avez défini unapply pour renvoyer un Boolean, vous indiquiez que le modèle n'a aucun caractère générique à faire correspondre (ou lier). La déclaration de cas pour cet extracteur doit donc être case NumberMatcher => println(str), et lui donner une variable à remplir est incorrect.

Sinon, pour faire case NumberMatcher(group) => println(group) vous devez définir unapply() pour retourner Option[String]

Answer 4

package com.tutorial.extracters 
object ExtracterwithBooleanReturnType extends App { 
import java.util.regex._ 
object NumberMatcher { 
    def apply(x: String*) = { 
    x 
    } 
    def unapply(x: String): Option[Boolean] = { 
    val pat = Pattern.compile("\\d+") 
    val matcher = pat.matcher(x) 
    return Some(matcher.find) 
} 
} 

val strings = NumberMatcher("geo12", "neo493", "leo") 
for (str <- strings) { 
    str match { 
    case NumberMatcher(group) => println(group) 
    case _ => println("no") 
} 
} 
} 

nous pouvons y parvenir avec le code ci-dessus ainsi