Muster-match in der foreach und dann einen endgültigen Schritt

Ist es möglich, etwas zu tun, nachdem Sie ein pattern match foreach Aussage?

Ich will ein post-match-Schritt z.B. um eine variable zu setzen. Ich möchte auch die Kraft eine Einheit zurück, wie meine foreach ist String => Einheit, und standardmäßig Scala will return die Letzte Anweisung.

Hier einige code:

    Iteratee.foreach[String](_ match {
      case "date" => out.push("Current date: " + new Date().toString + "<br/>")
      case "since" => out.push("Last command executed: " + (ctm - last) + "ms before now<br/>")
      case unknow => out.push("Command: " + unknown + " not recognized <br/>")
    } //here I would like to set "last = ctm" (will be a Long) 
    )

AKTUALISIERT:
Neuen code und Kontext. Auch neue Fragen Hinzugefügt 🙂 Sie sind eingebettet in den Kommentaren.

def socket = WebSocket.using[String] { request =>

 //Comment from an answer bellow but what are the side effects?
 //By convention, methods with side effects takes an empty argument list
 def ctm(): Long = System.currentTimeMillis

 var last: Long = ctm

 //Command handlers
 //Comment from an answer bellow but what are the side effects?
 //By convention, methods with side effects takes an empty argument list
 def date() = "Current date: " + new Date().toString + "<br/>"
 def since(last: Long) = "Last command executed: " + (ctm - last) + "ms before now<br/>"
 def unknown(cmd: String) = "Command: " + cmd + " not recognized <br/>"

 val out = Enumerator.imperative[String] {}

 //How to transform into the mapping strategy given in lpaul7's nice answer.
 lazy val in = Iteratee.foreach[String](_ match {
   case "date" => out.push(date)
   case "since" => out.push(since(last))
   case unknown => out.push(unknown)
 } //Here I want to update the variable last to "last = ctm"
 ).mapDone { _ =>
   println("Disconnected")
 }

 (in, out)
}

InformationsquelleAutor Farmor | 2012-07-03

Ich weiß nicht, was Ihr ctm ist, aber könnten Sie dies jederzeit tun:

val xs = List("date", "since", "other1", "other2")

xs.foreach { str =>

    str match {
        case "date"  => println("Match Date")
        case "since" => println("Match Since")
        case unknow  => println("Others")
    } 

    println("Put your post step here")
}

Hinweis: Sie verwenden sollten {} statt () wenn Sie möchten, verwenden Sie einen code-block, der als argument für foreach().

Man kann sogar noch einfacher: xs foreach { case "date" => .... }

InformationsquelleAutor Brian Hsu

3

Werde ich nicht beantworten Ihre Frage, aber ich sollte beachten Sie, dass die Neuzuweisung der Variablen in Scala ist eine schlechte Praxis. Ich schlage vor, Sie neu zu schreiben Ihren code zu vermeiden vars.

Ersten verwandeln Sie Ihr strings zu etwas anderem:
```
val strings = it map {
 case "date" => "Current date: " + new Date().toString + " "
 case "since" => "Last command executed: " + (ctm - last) + "ms before now "
 case unknow => "Command: " + unknown + " not recognized "
}
```
Nächste, schieben Sie es
```
strings map { out.push(_) }
```
Es sieht aus wie Ihre Umsetzung push hat Nebenwirkungen. Schlecht für Sie, weil solche Methoden macht das Programm unberechenbar. Sie können leicht Nebenwirkungen vermeiden, indem Sie push Gegenzug ein Tupel:
```
def push(s: String) = {
 ...
 (ctm, last)
}
```
Und es zu benutzen, wie:
```
val (ctm, last) = out.push(str)
```
Update:

Natürlich Nebenwirkungen, die notwendig sind, um Programme sinnvoll. Ich meinte auch nur, dass die Methoden in Abhängigkeit von äußeren Variablen sind weniger vorhersehbar als rein, es ist hart zu Grunde geht. Es ist einfacher zu testen Methoden ohne Nebenwirkungen.

Ja, sollten Sie lieber vals über vars, es macht das Programm mehr "funktional" und staatenlos. Zustandslose algorithmen sind thread-sicher und sehr vorhersehbar.

Wie es scheint, Ihr Programm wird stateful durch die Natur. Zumindest, versuchen zu bleiben, wie "funktional" und staatenlos, wie Sie können 🙂

Meine vorgeschlagene Lösung des Problems ist:
```
//By convention, methods with side effects takes an empty argument list
def ctm(): Long = //Get current time

//Command handlers
def date() = "Current date: " + new Date().toString + " "
def since(last: Long) = "Last command executed: " + (ctm() - last) + "ms before now "
def unknown(cmd: String) = "Command: " + unknown + " not recognized " 

 //In your cmd processing loop

 //First, map inputs to responses
 val cmds = inps map {
 case "date" => date()
 case "since" => since(last)
 case unk => unknown(unk)
 }

 //Then push responses and update state
 cmds map { response =>
 out.push(response)
 //It is a good place to update your state
 last = ctm()
 }
```
Ist es schwer, dies zu testen, ohne Zusammenhang mit Ihrer code, Sie sollten also passen Sie es Ihren Anforderungen an sich selbst. Ich hoffe, ich habe Ihre Frage beantwortet.

Vielen Dank für Ihre Antwort. Allerdings habe ich ein paar Fragen/Anmerkungen. In welcher Weise meinst du, dass mit den Nebenwirkungen ist schlecht? Der alleinige Zweck.push ist eine Nebenwirkung mehr bestimmten schreiben an den websocket. schieben Sie Sie wieder ein Gerät, wie es schiebt lediglich die String-thru-a-Buchse, also kann ich nicht zuweisen das Tupel gibt. Die Empfehlung von val anstatt var ist interessant. Meine funktionalen Fähigkeiten fehlen können und wäre viel zu schätzen Ihre aktualisierte Antwort in diesem Kontext. zuletzt wird eine Instanz-variable, die halten sollte currentTimeInMillies der letzten empfangenen Befehl durch den websocket. cdm ist ein def
Ja danke, ich verstehe, dass der Kontext vage, aktualisiert, meine Antwort zu geben, einen größeren Zusammenhang. Deine Antwort ist toll. Ich verstehe immer noch nicht den Sinn von Nebenwirkungen zum Beispiel, welche Seite Effekt Datum() verursacht? Auch meine Iteratee keine Unterstützung für die Karte?
Wo sind deine Iteratee kommen? Haben Sie versucht, Iteratee.Karte? Habe es kompiliert, oder geben Sie eine Fehlermeldung?

InformationsquelleAutor lambdas

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.