Scala Karte, implict Symbol Schlüssel zum String

Question

UPDATE
die Antworten Alle hier gut sind, aber @ senia der tut dies die am unmittelbarsten, ohne dass zusätzliche Schritte. Dies führt möglicherweise zu Fehlern, aber wenn die Map [Symbol, T] -Konvention in Hunderten von Methoden verwendet wird, wird eine einstufige implizite Konvertierung vor der Kartenerstellung bevorzugt (Vermeidung des Symbol-Map-Schlüssel-Permgenspeichers). Jedenfalls, hier ist der Zuhälter:

class SymbolProvidesPair(i: Symbol) { def ->[T](s: T) = (i.toString.tail, s) } 
@inline implicit def symbol2String(i: Symbol) = new SymbolProvidesPair(i) 

Original-
Es stört mich ein bisschen String-Schlüssel in Maps, verlangsamt mich nur nach unten und ist, IMO, nicht als syntaktisch einfach auf die Augen als Symboltasten .

val map: Map[String, Int] = Map("strings" -> 1, "blow" -> 2) 
val map: Map[String, Int] = Map('symbols -> 1, 'rock -> 2) 

Also, habe ich eine implizite mein Juckreiz zu kratzen:

implicit def symbolKey2String[A <: Symbol, B](x:(A,B)) = (x._1.toString, x._2) 

Paar Dinge:
1) ist dies die korrekte Signatur? Das obige funktioniert, aber A <: Symbol Ich meine, etwas, das von Symbol gegenüber etwas abstammt, das Symbol entspricht.

2) Ich werde dies verwenden, wenn ich Maps manuell eintippe; d.h. nur zur Bequemlichkeit. Werde ich irgendwelche Haken mit diesem impliziten treffen? Es scheint Rand Case genug, um keine Probleme (wie String2Int, zum Beispiel) zu verursachen, aber nicht sicher, ob ich etwas vermisse.

Dank

EDIT
Ok, gut 1 # kann ich eigentlich nur sagen, was ich meine, [Symbol, B] statt [A <: Symbol, B]

Aber jetzt habe ich mich mit einem anderen Problem zu finden, das Symbol-to- string implizit bringt mich in eine Ecke der Art, wie ich dann Map [String, Type] für alle neuen Maps explizit definieren muss (dh die nette Compiler-Typ-Inferenz verlieren), um Symbol-Schlüssel verwenden zu können.

Wie dann, um das Beste aus beiden Welten zu bekommen, Kartensymbolschlüssel, aber mit abgeleiteten [String, Type], wenn nicht die Typ-Signatur angeben? das heißt, den Compiler schließen Karte haben [String, Int], wenn ich tun:

val map = Map('foo -> 1) 

Answer 1

Sie brauchen nicht explizit Karte des Typ angeben:

scala> class SymbolToPait(i: Symbol) { def ->[T](s: T) = (i.toString().tail, s)} 
defined class SymbolToPait 

scala> implicit def symbolToPair(i: Symbol) = new SymbolToPait(i) 
symbolToPair: (i: Symbol)SymbolToPait 

scala> 'Symbol -> "String" 
res0: (String, String) = (Symbol,String) 

scala> Map('Symbol -> "String") 
res1: scala.collection.immutable.Map[String,String] = Map(Symbol -> String) 

scala> Map('Symbol -> 1) 
res2: scala.collection.immutable.Map[String,Int] = Map(Symbol -> 1) 

Diese Art von Verhalten anderer Entwickler überraschen könnte. Vielleicht wäre es besser, -> durch ein anderes Wort zu ersetzen? Zum Beispiel :-> oder ~>.

Answer 2

Wie Sie notiert haben, besteht keine Notwendigkeit für A. Sie wollen wahrscheinlich auch das erste Zeichen fallen zu lassen, das ist immer ein '

ist

implicit def symbolKeyToString[B](x: (Symbol, B)) = (x._1.toString.tail, x._2) 

Was Tücken, na ja, müssen Sie jedes Mal, wenn die Signatur der Karte tippen und Ihre Schlüssel darf keine Leerzeichen enthalten oder Betreiberzeichen. Das würde ich nicht selbst tun ...

Edit: wenn Sie wollen, jedes Mal, wenn die Signatur nicht tippen, eine Alternative zu Map.apply verwenden und implicits vergessen:

object Map2 { 
    def apply[B](xs: (Symbol, B)*) = 
    xs map {case (k, v) => (k.toString.tail, v)} toMap 
} 

Answer 3

Ich habe ein paar Warnungen über die aktuellen Lösungen.

Zunächst ändern Sie die Bedeutung von 'sym -> x, und es wird etwas anderes als ('sym, x) bedeuten. Ich würde das verwirrend finden.

Sie machen es auch schwierig, Code zu mischen, der diese Konvertierung mit Code verwendet, der tatsächlich Map[Symbol, _] benötigt.

Anstatt die Symbole in Zeichenfolgen zu konvertieren, bevor sie in eine Karte eingefügt werden, empfehle ich, die Karte einfach zu konvertieren. Scheint viel einfacher für mich.

scala> implicit def symMap2strMap[T](m: Map[Symbol, T]): Map[String, T] = m.map { 
    | case (key, value) => key.toString.tail -> value 
    | } 
symMap2strMap: [T](m: Map[Symbol,T])scala.collection.immutable.Map[String,T] 

scala> val sym = Map('foo -> 1, 'bar -> 2) 
sym: scala.collection.immutable.Map[Symbol,Int] = Map('foo -> 1, 'bar -> 2) 

scala> sym: Map[String, Int] 
res0: Map[String,Int] = Map(foo -> 1, bar -> 2) 

bearbeiten:

Sie sollten nie den Typ explizit zu konvertieren Map[Symbol, T] zu Map[String, T] angeben. Lassen Sie es einfach als Map[Symbol, T], bis Sie eine API treffen, die Zeichenfolgenschlüssel benötigt, dann lassen Sie Scala implizit in den gewünschten Typ konvertieren.