Est-il possible d'avoir les tuples avec les nom des champs dans la Scala, semblable à un anonyme classes en C#?

object T {
  def main(args: Array[String]) {  
    val e = new { var id = 5; var name = "Prashant" }
    assert(e.id == 5)
  }
}

Ok, nous allons faire des trucs clair. Ce n'utiliser la réflexion sur la Scala de 2,7 et Scala 2.8, parce que le type de e est, dans ce cas, un type de structure, qui Scala poignées par la réflexion. Voici le code généré, à nettoyer de temps (scalac -Xprint:cleanup):

package <empty> {
final class T extends java.lang.Object with ScalaObject {
private <synthetic> <static> var reflMethod$Cache1: java.lang.reflect.Method = null;
private <synthetic> <static> var reflClass$Cache1: java.lang.Class = null;
<synthetic> <static> def reflMethod$Method1(x$1: java.lang.Class): java.lang.reflect.Method = {
if (T.this.reflMethod$Cache1.eq(null).||(T.this.reflClass$Cache1.ne(x$1)))
{
T.this.reflMethod$Cache1 = x$1.getMethod("id", Array[java.lang.Class]{});
T.this.reflClass$Cache1 = x$1;
()
};
T.this.reflMethod$Cache1
};
@remote def $tag(): Int = scala.ScalaObject$class.$tag(T.this);
def main(args: Array[java.lang.String]): Unit = {
val e: java.lang.Object = {
new T$$anon$1()
};
scala.this.Predef.assert(scala.Int.unbox({
var exceptionResult1: java.lang.Object = _;
try {
exceptionResult1 = T.reflMethod$Method1(e.getClass()).invoke(e, Array[java.lang.Object]{})
} catch {
case ($1$ @ (_: java.lang.reflect.InvocationTargetException)) => {
exceptionResult1 = throw $1$.getCause()
}
};
exceptionResult1
}.$asInstanceOf[java.lang.Integer]()).==(5))
};
def this(): object T = {
T.super.this();
()
}
};
final class T$$anon$1 extends java.lang.Object {
private[this] var id: Int = _;
<accessor> def id(): Int = T$$anon$1.this.id;
<accessor> def id_=(x$1: Int): Unit = T$$anon$1.this.id = x$1;
private[this] var name: java.lang.String = _;
<accessor> def name(): java.lang.String = T$$anon$1.this.name;
<accessor> def name_=(x$1: java.lang.String): Unit = T$$anon$1.this.name = x$1;
def this(): T$$anon$1 = {
T$$anon$1.this.id = 5;
T$$anon$1.this.name = "Prashant";
T$$anon$1.super.this();
()
}
}
}

Il ya une certaine mise en cache des choses, mais si j'ai alterné entre id et name il invalide le cache déjà. Scala 2.8 fait aussi de la réflexion, et aussi les caches, mais il utilise un système plus efficace de la mise en cache de la technique, ce qui devrait fournir une meilleure performance globale. Pour référence, voici le nettoyage de la Scala 2.8:

package <empty> {
final class T extends java.lang.Object with ScalaObject {
final private <synthetic> <static> var reflParams$Cache1: Array[java.lang.Class] = Array[java.lang.Class]{};
@volatile
private <synthetic> <static> var reflPoly$Cache1: scala.runtime.MethodCache = new scala.runtime.EmptyMethodCache();
<synthetic> <static> def reflMethod$Method1(x$1: java.lang.Class): java.lang.reflect.Method = {
var method1: java.lang.reflect.Method = T.reflPoly$Cache1.find(x$1);
if (method1.ne(null))
return method1
else
{
method1 = x$1.getMethod("id", T.reflParams$Cache1);
T.reflPoly$Cache1 = T.reflPoly$Cache1.add(x$1, method1);
return method1
}
};
def main(args: Array[java.lang.String]): Unit = {
val e: java.lang.Object = {
new T$$anon$1()
};
scala.this.Predef.assert(scala.Int.unbox({
val qual1: java.lang.Object = e;
{
var exceptionResult1: java.lang.Object = _;
try {
exceptionResult1 = T.reflMethod$Method1(qual1.getClass()).invoke(qual1, Array[java.lang.Object]{})
} catch {
case ($1$ @ (_: java.lang.reflect.InvocationTargetException)) => {
exceptionResult1 = throw $1$.getCause()
}
};
exceptionResult1
}.$asInstanceOf[java.lang.Integer]()
}).==(5))
};
def this(): object T = {
T.reflParams$Cache1 = Array[java.lang.Class]{};
T.reflPoly$Cache1 = new scala.runtime.EmptyMethodCache();
T.super.this();
()
}
};
final class T$$anon$1 extends java.lang.Object {
private[this] var id: Int = _;
<accessor> def id(): Int = T$$anon$1.this.id;
<accessor> def id_=(x$1: Int): Unit = T$$anon$1.this.id = x$1;
private[this] var name: java.lang.String = _;
<accessor> def name(): java.lang.String = T$$anon$1.this.name;
<accessor> def name_=(x$1: java.lang.String): Unit = T$$anon$1.this.name = x$1;
def this(): T$$anon$1 = {
T$$anon$1.super.this();
T$$anon$1.this.id = 5;
T$$anon$1.this.name = "Prashant";
()
}
}
}

Je voudrais simplement faire une classe de cas:

object Yo{
case class E(id: Int, name: String)
def main(){
val e = E(5,"Prashant")
println("name="+e.name+", id="+e.id)
}
}

Ne sais pas si c'est aussi efficace que La réponse de Daniel mais je pense que c'est le même (je vous en serais reconnaissant commentaires sur l'). En tout cas, je trouve ça plus lisible, en utilisant une seule ligne supplémentaire qui est partagé si vous avez plus d'un exemple, si E. Vous pouvez également ajouter une méthode à la classe de cas, tels que:

case class E(id: Int, name: String){
def hasId(id: Int) = this.id==id
}
val e = E(5,"Prashant")
assert(e hasId 5)

Scala 2.8 a amélioré le système de type, au point qu'il est possible d'avoir de manière statique et hétérogène tapé des tableaux et des listes, donc vraisemblablement la même chose pourrait être fait avec des cartes. Découvrez Jesper Nordenberg blog sur "Type de Listes et Hétérogène Tableaux Typés" pour sa mise en œuvre.