类型类、隐式转换、多类型参数

Question

我正在尝试创建一个具有多个类型参数的类型类。 我正在尝试根据类型隐式调用该方法

我正在展示我尝试过的代码的简单 sn-p。

object operation {
// Define generic trait class
  trait Operator[T, U] {
    def addition[T, U](l: U, r: T)(implicit p: Parameters): U
  }


  object Operator {
// Define type class.
    implicit object IntOperator extends Operator[Int, Float] {
      def addition(l: Int, r: Float): Float = {
        r
      }
    }
  }
// Create mapping for implicit call.
  def addition[T, U](l: T, r: U)(implicit op: Operator[T, U]): U = op.addition(l, r,)
  }

import  operation._

def fn(a: UInt, b: Float)
addition(a,b)

如果我使用单个类型参数，即只有 [T,U]，那么这段代码编译得很好。但是，如果我使用两个类型参数，即 Operator[T,U] 那么添加（a，b）会抱怨 未找到参数 Operator[T,U] 的隐式。任何帮助将不胜感激。

我希望简化的代码 sn-p 详细说明我正在尝试做的事情。

Answer 1

只是为了让您知道它可以按预期编译和工作。

object operation {
  trait Operator[T, U] {
    def addition(l: T, r: U): U
  }

  object Operator {
    implicit final val IntFloatOperator: Operator[Int, Float] =
      new Operator[Int, Float] {
        override def addition(l: Int, r: Float): Float = l + r
      }
  }

  def addition[T, U](l: T, r: U)(implicit op: Operator[T, U]): U = op.addition(l, r)
}

def fn(a: Int, b: Float): Float = operation.addition(a, b)
fn(1, 10.0f) // 11.0F

---

编辑

解决评论您可以：

1) 提供所需的隐式。

def fn[T1 <: Int, T2 <: Float](a: T1, b: T2)(implicit op: Operator[T1, U1]): U1 =
  op.addition(a, b)

（注意：该方法的用户负责在范围内为他/她使用的类型提供类型为 Operator[T1, U1] 的隐式。） em>

2) 显式调用 IntFloatOperator。

def fn[T1 <: int t2 float t1 b: b>

（注意：提供自定义召唤师是很常见的，以减少样板。）

object Operator {
  // Summoner.
  def apply[T, U](implicit op: Operator[T, U]): Operator[T, U] = op

  ...
}

def fn[T1 <: Int, T2 <: Float](a: T1, b: T2): T2 =
  Operator[Int, Float].addition(a, b)