Wie verwendet man Mustervergleich, um eine nicht leere Liste in scala zu erhalten?

Question

Ich benutze case x :: Nil => ... versuchen, um sicherzustellen, dass die Liste nicht leer ist, aber es nur einzelne Element Liste übereinstimmen.Wie kann ich Muster Übereinstimmung erhalten eine nicht leere Liste?

AKTUALISIERT
Es tut mir leid, es scheint, dass ich etwas zu verlieren, gibt es eine spezielle Szene ist das Spiel verwenden innere,

object AccountResult{ 
    def unapply(account: AccountResult): Option[(String, List[String])] = ??? 
} 

//ignore accountResult define please 
accountResult match { 
    case AccountResult(_, x :: _) => ... 
} 

wie kann ich accountResult welche Liste [Zeichenfolge] (x entsprechen: : _) Wert ist nicht Nil? und dann erhalten die angepassten Liste [Zeichenfolge] Wert

Answer 1

Statt nur die leere Liste mit Nil anzugeben, gibt etwas, das jede Liste sein kann, zB .:

case x :: tail => ... // tail is a local variable just like x, holding the tail of the list 

oder einfach:

case x :: _ => ... 

Wenn Sie nicht interessiert sind oder nicht den Schwanz verwenden werden.

Diese Muster werden mit mindestens ein Element (statt genau ein Element wie pro Ihre vorhandenen Muster) jede Liste übereinstimmen. In ähnlicher Weise das Muster:

case x :: y :: the_rest => ... 

mit mindestens zwei Elementen jede Liste übereinstimmen.

bearbeiten (Antwort auf Ihren Kommentar):

Sie auf eine Variable in einem Fall Muster zuordnen können „@“ verwenden.Also, für (eine typische Verwendung) Beispiel, die Sie bereits gesehen haben:

case acc@AccountResult(_, x :: tail) => ... // do something with 'acc' 

oder Anpassung der Nutzung Sie nach Ihren Kommentar suchen sind:

case AccountResult(_, phone@(x :: tail)) => ... // do something with 'phone' 

Answer 2

Um zu überprüfen, ob die Liste nicht leer Sie ist können Muster auf diese Weise entsprechen:

list match { 
    case Nil => false 
    case _ => true 
} 

Oder

list match { 
    case Nil => false 
    case x::xs => true 
} 

Answer 3

Ist dies etwas, das Sie häufig verwenden Sie eine benutzerdefinierte Matcher wie folgt erstellen:

scala> List() match { case NonEmpty(l) => println(l) } 
scala.MatchError: List() (of class scala.collection.immutable.Nil$) 
    ... 33 elided 

scala> List(43) match { case NonEmpty(l) => println(l) } 
List(43) 

scala> List(43, 32) match { case NonEmpty(l) => println(l) } 
List(43, 32) 

Answer 4

Wenn Sie nur eine ganze nicht leer zuweisen möchten:

object NonEmpty { 
    def unapply(l: List[_]) = l.headOption.map(_ => l) 
} 

Dies kann wie folgt verwendet werden Liste mit einem val, ohne Splitting Kopf und Schwanz, fügen Sie nur einen Fall, eine leere Liste übereinstimmt, und eine andere, die Liste zu einem Variablennamen wie diese Zuordnung:

accountResult match { 
    case List() => ??? // empty case 
    case myAccountResult => ??? //myAccountResult will contain the whole non-empty list 
} 

Nil erledigt den Job auch, eine leere Liste passend

accountResult match { 
    case Nil => ??? // empty case 
    case myAccountResult => ??? //myAccountResult will contain the whole non-empty list 
}