Pattern matching auf eine Liste, in der Scala

Ich bin ein wenig verwirrt über pattern-matching auf eine Liste, in der Scala.

Zum Beispiel.

    val simplelist: List[Char] = List('a', 'b', 'c', 'd')

    //> simplelist  : List[Char] = List(a, b, c, d)

    def simple_fun(list: List[Char]) = list match {
           case (x:Char) :: (y:List[Char]) => println(x)
           case _ => Nil
     }                                                 
   //> simple_fun: (list: List[Char])Any

   simple_fun(simplelist)                            

   //> a
   //| res0: Any = ()

Diese derzeit druckt nur eine Zeile der Ausgabe. Sollte es nicht laufen/Muster passen auf jedes element der Liste ?

EDIT: ich der compile-Fehler und kopiert die Ausgabe von REPL.

InformationsquelleAutor Soumya Simanta | 2012-10-24

23

Es sei denn, Sie sind immer wieder ruft simple_fun in gewisser Weise, das was du da hast wird das Muster mit dem ersten element und nichts mehr. Um es entsprechend die ganze Liste, Sie können Holen Sie simple_fun zu sich selbst rekursiv aufruft, so aus:
```
val simplelist: List[Char] = List('a', 'b', 'c', 'd')

def simple_fun(list: List[Char]): List[Nothing] = list match {
  case x :: xs => {
    println(x)
    simple_fun(xs)
  }
  case _ => Nil 
}
```
Hinweis habe ich auch ließen einige der Arten, wie der Scala-compiler kann daraus schließen Sie, verlassen Sie mit weniger überladen, mehr lesbaren code.

Als kleine Randbemerkung, ruft println wiederholt innerhalb der Funktion ist nicht besonders funktional - wie es ist alles über die Nebenwirkungen. Eine weitere idiomatischen Ansatz wäre, die Funktion haben, erstellen Sie eine Zeichenfolge Beschreibung die Liste, die dann eine Ausgabe mit einem einzelnen Aufruf von println - also die Nebenwirkungen halten sich in einer einzigen, gut definierten Platz. So etwas wie dieses wäre ein Ansatz:
```
def simple_fun(list: List[Char]):String = list match {
  case x :: xs => x.toString + simple_fun(xs)
  case Nil => ""
}

println(simple_fun(simple_list))
```
- Danke. Also die Musterübereinstimmung wird nur einmal aufgerufen werden und nicht für jedes element in der Liste. Auch ich hatte, um einen return-Typ (Einheit) ausdrücklich zu simple_fun zu können, rufen Sie rekursiv.
- Kein problem! Ja, ich habe gemerkt, dass (etwa rekursive Funktionen, die einen Rückgabewert-Typ), während das hinzufügen von ein wenig der Klarstellung für die Antwort, so bearbeitet es zu beheben. Haben Sie sich schon nach dem scala-Kurs auf coursera.org?
- Ich verstehe, dass println produziert Nebenwirkungen. Ich habe es nur für dieses einfache Beispiel. Ich Stimme zu, es sollte nicht Teil der eigentlichen code, wenn man will, rein funktional.
- Naja, dein code hat, haben Nebenwirkungen, wenn Sie irgendwo wollen, dass es auf do nichts! Aber der trick ist, halten Sie isoliert.
- Im Allgemeinen, Sie besser glauben, dass pattern matching ist eine Allgemeine Funktion, die auf ein "einzelnes Objekt" zu einer Zeit: x match { case ... } bedeutet, dass Sie versuchen, zu bewerten, wie x gemacht wird und dann etwas tun, basierend auf, dass. Wenn Sie es auf eine x: List[T] die match werden versuchen, herauszufinden, was ist die case dass "identifiziert x besten" und zu bewerten, was nach der entsprechenden =>. Es hat nichts zu tun mit Durchlaufen der Liste.
InformationsquelleAutor Russell
1

Ich denke, Folgendes sollte funktionieren:
```
def flatten(l: List[_]): List[Any] = l match {
  case Nil => Nil
  case (head: List[_]) :: tail => flatten(head) ::: flatten(tail)
  case head :: tail => head :: flatten(tail)
}
```
Die erste Zeile ist ein Spiel für Null, so dass, wenn wir etwas nicht finden nichts zurück.
Die zweite Zeile identifizieren, die Liste der Listen und erinnern an die Methode flatten und glätten Sie die Liste der Listen.
- Diese Frage wurde beantwortet, und die Antwort wurde akzeptiert, vor 4 Jahren. Nicht nur, dass Ihre Antwort ein wenig spät, um der Partei, ist es auch verfehlt den Punkt. Die Frage war über einfache Mustererkennung. Es gibt nichts in der Frage über verschachtelte Listen.
InformationsquelleAutor Manoj Shah

Ich möchte auch erwähnen, dass der Fall für Listen aufgeteilt werden können und nicht nur Kopf und Schwanz, sowie alle N Anzahl der Listenelemente:

def anyFunction(list: List[Int]): Unit =
  list match {
        //...methods that have already been shown
      case first :: second :: Nil  => println(s"List has only 2 elements: $first and $second")
      case first :: second :: tail => println(s"First: $first \nSecond: $second \nTail: $tail")
  }

Hoffe, es wird nützlich sein, um jemanden.

InformationsquelleAutor S.Dayneko

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.