Scala/Chiselの型パラメータを持つOveride/Overload演算子

Question

私はChiselを使用していますが、実際これはScalaの問題です。 私がしようとしているのは、派生オブジェクトの>演算子をオーバーライドすることです。 次のクラスを考慮すると：

class Record extends Bundle { 
    val key = UInt(32.W) 
    val data = UInt(8.W) 
    def > (rhs:Record) = key > rhs.key 
} 

class RecordIndexed extends Record { 
    val index = UInt(8.W) 
    def > (rhs:RecordIndexed) = key > rhs.key || (key === rhs.key && index > rhs.index) 
} 

それから私はレコードから派生した任意のレコードタイプの一般的なコンパレータを構築したいと思います：

class Comparator[T <: Record](gen: T) extends Module { 
    val io = IO(new bundle { 
     val a = Flipped(Valid(gen)) 
     val b = Flipped(Valid(gen)) 
     val o = Output(Bool()) 
    } 

    io.o := io.a.valid && io.b.valid && io.a.bits > io.b.bits 
} 

私は

Comparator(new Record) 

を使用することはOKです

しかし、試してみると失敗します

Comparator(new RecordIndexed) 

コンパイラは渡しますが、>演算子は常にRecordIndexedのものではなくRecordのものです。

なぜなら、>はオーバーライドではなくオーバーロードだからです。コンパイラのタイプTによると、コンパイラは>レコードから静的に選択します。

この問題を回避し、Scalaにオーバーロードを選択させるにはどうすればよいですか>。私は型付きの特性が行く方法だと思うが、完全にどのように把握することに失敗した。 @での質問に編集からコピー

Answer 1

魏歌：

@dveimからの提案によると、私は最終的にそれが動作、型クラスを試してみました：

class Record extends Bundle { 
    val key = UInt(32.W) 
    val data = UInt(8.W) 
} 

class RecordIndexed extends Record { 
    val index = UInt(8.W) 
} 

object record_operation { 
    trait RecordLike[t] { 
     def isLarger(l: T, r: T): Bool 
    } 

    object RecordLike { 
     implicit object RecordLikeRecord extends RecordLike[Record] { 
      def isLarger(l: Record, r: Record): Bool = 
       l.key > r.key 
     } 

     implicit object RecordLikeRecordIndexed extends RecordLike[RecordIndexed] { 
      def isLarger(l: RecordIndexed, r: RecordIndexed): Bool = 
       l.key > r.key || (l.key === r.key && l.index > r.index) 
     } 
    } 

    def larger[T](l: T, r: T)(implicit op: RecordLike[T]): Bool = op.isLarger(l, r) 
} 

class Comparator[T <: Record : RecordLike](gen: T) extends Module { 
    val io = IO(new bundle { 
     val a = Flipped(Valid(gen)) 
     val b = Flipped(Valid(gen)) 
     val o = Output(Bool()) 
    } 
    import record_operation._ 
    io.o := io.a.valid && io.b.valid && larger(io.a.bits, io.b.bits) 
}