La conversion implicite de tableau pour la liste

Comment puis-je écrire une conversion implicite de Array[_] à List[_] type? J'ai essayé ce qui suit, mais il ne semble pas fonctionner.

scala> implicit def arrayToList[A : ClassManifest](a: Array[A]): List[A] = a.toList
<console>:5: error: type mismatch;
 found   : Array[A]
 required: ?{val toList: ?}
Note that implicit conversions are not applicable because they are ambiguous:
 both method arrayToList in object $iw of type [A](a: Array[A])(implicit evidence$1: ClassManifest[A])List[A]
 and method genericArrayOps in object Predef of type [T](xs: Array[T])scala.collection.mutable.ArrayOps[T]
 are possible conversion functions from Array[A] to ?{val toList: ?}
       implicit def arrayToList[A : ClassManifest](a: Array[A]): List[A] = a.toList
                                                                           ^

OriginalL'auteur Miguel Fernandez | 2011-02-13

  1. 8
    implicit def arrayToList[A](a: Array[A]) = a.toList

    Semble fonctionner comme prévu. Ma conjecture est qu'il y a déjà un genericArrayOps dans Predef a la signature pour la conversion implicite de Array[T] -> ArrayOps[T], ArrayOps[T] a une méthode .toList(): List[T]. Votre méthode a la signature Array[T] -> List[T], ce qui rend également la méthode .toList[T] disponibles. Le corps est de demander une conversion implicite avec cette signature. Le compilateur ne sait pas que l'utilisation de arrayToList fera que la méthode d'aller dans une boucle infinie, d'où l'erreur d'ambiguïté. Cependant, le type d'inférence du type de retour semble être en mesure de contourner ce problème. Implicites de résolution de ne pas jive très bien avec l'inférence de type, il me semble.

    Également intéressant de noter, c'est que depuis il y a déjà une conversion implicite que vous obtiendrez ce que vous voulez par défaut, il n'y a pas besoin d'avoir une conversion implicite de Array à List.

    La convention de nommage XxxOps toujours suggère que vous voyez pimped les méthodes d'extension pour le type Xxx
    Cela a été utile pour moi. J'ai un tableau qui peut être null (renvoyée à partir d'un JDBC appel, de sorte Option n'est pas une option), et à l'aide de votre explication/solution de contournement, j'ai été en mesure de créer un implicite à manipuler: implicit def nullableArrayToList[T](array: Array[T]) Option(array).fold(List.empty[T]) { _.toList }

    OriginalL'auteur Y.H Wong

  2. 6

    Il n'y a pas besoin d'un Manifest ou ClassManifest lors de la conversion de de des tableaux, comme Array est une "collection" de type qui obtient le traitement spécial de la JVM et de ne pas subir le type d'effacement.

    Cela signifie que vous pouvez aller avec l'évidente/trivial approche, pas de truc requis:

    implicit def arrayToList[A](arr: Array[A]) = arr.toList

    Une question cependant... étant Donné que .toList est déjà une opération triviale, que gagnez-vous en la rendant implicite?

    Bonjour mystère downvoter. Puis-je demander... pourquoi?

    OriginalL'auteur Kevin Wright