¿Puedo sobrecargar paréntesis en Scala?

Question

Tratando de averiguar cómo sobrecargar paréntesis en una clase.

tengo este código:

class App(values: Map[String,String]) 
{ 
    // do stuff 
} 

Me gustaría ser capaz de acceder a los valores de mapa de esta manera:

var a = new App(Map("1" -> "2")) 
a("1") // same as a.values("1") 

Es esto posible?

Answer 1

Necesita definir un método apply.

class App(values: Map[String,String]) { 
    def apply(x:String) = values(x) 
    // ... 
} 

Answer 2

creo que funciona usando aplican: How does Scala's apply() method magic work?

Answer 3

Como otros ya han señalado, que desea sobrecargar apply:

class App(values: Map[String,String]) { 
    def apply(s: String) = values(s) 
} 

Mientras estás en ello, es posible que desee a la sobrecarga el objeto acompañante también se aplica:

object App { 
    def apply(m: Map[String,String]) = new App(m) 
} 

Luego puede:

scala> App(Map("1" -> "2")) // Didn't need to call new! 
res0: App = App@5c66b06b 

scala> res0("1") 
res1: String = 2 

aunque si esto es un beneficio o una confusión dependerá de lo que está tratando de hacer.

Answer 4

Para completar, se debe decir que su "aplicar" puede tomar múltiples valores, y que "actualizar" funciona como el doble de "aplicar", permitiendo "sobreescribir paréntesis" en el lado izquierdo de las asignaciones

Class PairMap[A, B, C]{ 
    val contents: mutable.Map[(A,B), C] = new mutable.Map[(A, B), C](); 
    def apply(a:A, b:B):C = contents.get((a, b)) 
    def update(a:A, b:B, c:C):Unit = contents.put((a, b), c) 
} 

val foo = new PairMap[String, Int, Int]() 
foo("bar", 42) = 6 
println(foo("bar", 42)) // prints 6 

El valor principal de todo esto es que se mantiene a la gente de lo que sugiere la sintaxis extra para cosas que tenían que ser entubado-especial en las lenguas de la familia C-anteriores (por ejemplo, asignación de elemento de la matriz a buscar). También es útil para métodos de fábrica en objetos de compañía. Aparte de eso, se debe tener cuidado, ya que es una de esas cosas que fácilmente pueden hacer que su código sea demasiado compacto para ser realmente legible.