Impossible de trouver le valeur implicite pour le paramètre de commande

Question

je reçois l'erreur suivante lorsque vous essayez de compiler ceci:

Btree.scala: 9: Erreur: n'a pas pu trouver la valeur implicite pour la commande de paramètre: Commande [K] classe abstraite noeud [K, V] étend TreeMap [K, V]

TreeMap est censé accepter une commande implicite [A] val que je propose. Peut-être le paramètre implicite doit être dans l'objet Tester où le Btree (TreeMap) est instancié? Je préférerais garder la déclaration implicite à l'intérieur de la classe Btree parce que je voudrais commande d'avoir un type K qui implémente Comparable [K]. Avoir du sens?

package disttree { 
    import scala.collection.immutable.TreeMap 

    class Btree[K <: Comparable[K],V](fanout:Int) { 
     implicit object DefaultOrder extends Ordering[K] { 
      def compare(k1: K, k2: K) = k1 compareTo k2 
     } 

     abstract class Node[K,V] extends TreeMap[K,V] 

     class InnerNode[K,V] extends Node[K,V] 

     class LeafNode[K,V] extends Node[K,V] 

     val root = new InnerNode[K,V]() 

     def search(n: Node[K,V], key: K): Option[(K,V)] = { 
      return n.find(_ == key) 
     } 

     def insert(key: K, value: V) { } 

     def delete(key: K) { } 
    } 
} 

import disttree._; 
object Tester { 
    def main(args: List[String]) = { 
     var t = new Btree[Int, Any](2) 
     t.insert(1, "goodbye") 
     Console.println(t) 
    } 
} 

Answer 1

Cette compile et présente deux variantes, l'une en utilisant les touches Ordered (K) et l'autre à l'aide d'un Ordering sur les touches:

package disttree { 
    import scala.collection.immutable.TreeMap 
    import scala.math.{Ordered, Ordering} 

// class Btree[K <% Ordered[K], V](fanout:Int) // Using Ordered 
    class Btree[K : Ordering, V](fanout:Int) // Using Ording 
    { 
    /* Using Ordered 
     implicit object DefaultOrder extends Ordering[K] { 
      def compare(k1: K, k2: K) = k1 compareTo k2 
     } 
    */ 

    /* Using Ordering */ 
     val keyOrdering = implicitly[Ordering[K]] 

     implicit object DefaultOrder extends Ordering[K] { 
      def compare(k1: K, k2: K) = keyOrdering.compare(k1, k2) 
     } 

     abstract class Node extends TreeMap[K,V] 

     class InnerNode extends Node 

     class LeafNode extends Node 

     val root = new InnerNode() 

     def search(n: Node, key: K): Option[(K,V)] = { 
      return n.find(_ == key) 
     } 

     def insert(key: K, value: V) { } 

     def delete(key: K) { } 
    } 
} 

import disttree._; 
object Tester { 
    def main(args: List[String]) = { 
     var t = new Btree[Int, Any](2) 
     t.insert(1, "goodbye") 
     Console.println(t) 
    } 
} 

Answer 2

erreur commune. Ce sont deux s différentes K de »:

class Btree[K <: Comparable[K],V](fanout:Int) { 
    // The K below is the type parameter of Btree 
    implicit object DefaultOrder extends Ordering[K] { 
     def compare(k1: K, k2: K) = k1 compareTo k2 
    } 

    // The K in the error is the type parameter of Node 
    abstract class Node[K,V] extends TreeMap[K,V] 

    // And this is yet another K 
    class InnerNode[K,V] extends Node[K,V] 

    // And yet another 
    class LeafNode[K,V] extends Node[K,V] 

Utilisation -explaintypes -uniqid et passant le paramètre explicitement, je reçois ceci:

<console>:13: error: type mismatch; 
found : Btree#31335.this.DefaultOrder#31343.type (with underlying type object Btree#31335.this.DefaultOrder#31344) 
required: Ordering#3222[K#31346] 
       abstract class Node[K,V] extends TreeMap[K,V]()(DefaultOrder) 
                  ^
Btree#31335.this.DefaultOrder#31343.type <: Ordering#3222[K#31346]? 
    object Btree#31335.this.DefaultOrder#31344 <: scala.math.Ordering#11986[K#31346]? 
    scala.math.Ordering#11986[K#31336] <: scala.math.Ordering#11986[K#31346]? 
     K#31346 <: K#31336?