Definition einer Map von String-Funktion in Scala

Ich versuche zu definieren, eine Karte literal mit Schlüssel: String, Wert: (Any)=>String. Ich habe Folgendes versucht, bekomme aber immer einen syntax error:

def foo(x: Int): String = /...
def bar(x: Boolean): String = /...
val m = Map[String, (Any) => String]("hello" -> foo, "goodbye" -> bar)

Auch wenn die syntax in deiner Frage war, muss es etwas lustig, dass du das machst mit dem Typen zu schicken, die richtige Art der Funktion, die Sie von der Karte. Es gibt eine Menge weitere Komplikation hier. Was sind Sie wirklich versucht, zu tun? Vielleicht gibt es eine bessere Lösung völlig, dass der sich nicht auf eine Karte der Funktionen der verschiedenen Arten.

InformationsquelleAutor Ralph | 2011-01-06

Komisch, dass niemand wirklich gab einen Typ, der würde Arbeit. Hier ist eine solche:

def foo(x: Int): String = x.toString
def bar(x: Boolean): String = x.toString
val m = Map[String, (Nothing) => String]("hello" -> foo, "goodbye" -> bar)

Der Grund, warum es funktioniert auf diese Weise ist, weil Function1 ist die contra-Variante auf den Eingang, so (Nothing) => String ist eine Superklasse von (Int) => String. Es ist auch co-Variante auf den Ausgang, so (Nothing) => Any wäre eine Superklasse für alle anderen Function1.

Natürlich, Sie können es nicht verwenden, wie, dass. Ohne manifeste, können Sie nicht einmal herausfinden, was in den ursprünglichen Typ des Function1 ist. Sie könnten versuchen, so etwas wie dieses, aber:

def f[T : Manifest](v: T) = v -> manifest[T]
val m = Map[String, ((Nothing) => String, Manifest[_])]("hello" -> f(foo), "goodbye" -> f(bar))

val IntManifest = manifest[Int]
val BooleanManifest = manifest[Boolean]
val StringManifest = manifest[String]
m("hello")._2.typeArguments match {
    case List(IntManifest, StringManifest) =>
        m("hello")._1.asInstanceOf[(Int) => String](5)
    case List(BooleanManifest, StringManifest) =>
        m("hello")._1.asInstanceOf[(Boolean) => String](true)
    case _ => "Unknown function type"
}

InformationsquelleAutor Daniel C. Sobral

4

Int => String ist nicht eine Unterklasse von Jedem => String, eher das Gegenteil. Sie können nicht (ersetzen) Int => String-Funktion, wenn ein code erwartet einen => String, da dieser code kann die Funktion mit, sagen wir, "Hallo".

@Ben Vorschlag funktioniert, aber wie ist es nützlich? Sie können nicht zum aufrufen der Funktion, sobald man es aus der Karte.

Wenn Sie wirklich wollen, dies zu tun, vielleicht define foo als eine partielle Funktion:
```
val foo: PartialFunction[Any, String] = {case i: Int => ....}
```
Natürlich, dies wird zur Laufzeit scheitern, wenn Sie übergeben einen string, aber man kann immer testen, ob die Funktion ok ist für die Verwendung mit Ihre parameter mithilfe isDefinedAt. (eine weitere alternative sein kann, zeigt, aber ich sehe nicht den Wert hier)
- Ja, ich bin über post die Frage, "wie rufen Sie ihn?", denn ich weiß mich nicht.
- Oops, wusste ich nicht definieren foo Recht. Behoben
InformationsquelleAutor IttayD

Wenn ich lassen Sie der compiler es mir scheinen, um eine illegale Form:

scala> val m = Map("hello" -> foo _, "goodbye" -> bar _)
m: scala.collection.immutable.Map[java.lang.String,(Boolean with Int) => String] =
                Map((hello,<function1>), (goodbye,<function1>))

scala> m("hello")(8)
<console>:9: error: type mismatch;
 found   : Int(8)
 required: Boolean with Int
       m("hello")(8)
scala> var q = new Boolean with Int
<console>:5: error: illegal inheritance from final class Boolean
       var q = new Boolean with Int

Sowieso, was Sie wollen, ist nicht der Typ Any aber eine generische für "jede Art", die _:

scala> val mm = Map[String, (_) => String]("hello" -> foo _, "goodbye" -> bar _)
mm: scala.collection.immutable.Map[String,Function1[_, String]] =
               Map((hello,<function1>), (goodbye,<function1>))

Ich habe gerade gebucht eine Frage zu gewusst wie: aufrufen von Funktionen, weil ich eigentlich gar nicht wissen.

InformationsquelleAutor Ben Jackson

Eigenschaft Function1 ist kontravariant für parameter, so def foo(x: Int): String ist nicht ein (Any) => String. Also Folgendes funktionieren würde:

scala> def baz(x: Any): String = "baz"                         
baz: (x: Any)String

scala> val m2 = Map[String, (String) => String]("hello" -> baz)
m2: scala.collection.immutable.Map[String,(String) => String] = Map((hello,<function1>))

InformationsquelleAutor Eugene Yokota

Dies ist, wie ich es Tat, erfüllen eine ähnliche Anforderung.

object MapToMethods {
private def increment(x: Int): Int = x+1
private def decrement(x: Int): Int = x-1

val m: Map[String, Int => Int] =Map("increment" -> increment, "decrement" ->decrement)

println(m("increment")(2)) //prints 3
println(m("decrement")(3)) //prints 2
}

InformationsquelleAutor ShailyGarg

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.