Scala 编译器无法识别视图绑定

发布于 2024-10-07 04:38:25 字数 366 浏览 1 评论 0原文

我已经尝试过这行代码

def **[A <% Numeric[A]](l:List[A],m:List[A])=l.zip(m).map({t=>t._1*t._2})

但是在编译时,我收到此错误

error: value * is not a member of type parameter A
def **[A <% Numeric[A]](l:List[A],m:List[A])=l.zip(m).map({t=>t._1*t._2})

当我查看数字特征的源代码时,我看到定义了 * 操作。

我做错了什么?

I've tried this line of code

def **[A <% Numeric[A]](l:List[A],m:List[A])=l.zip(m).map({t=>t._1*t._2})

However on compilation, I get this error

error: value * is not a member of type parameter A
def **[A <% Numeric[A]](l:List[A],m:List[A])=l.zip(m).map({t=>t._1*t._2})

When I look at the source for the Numeric trait, I see a * op defined.

What am I doing wrong?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(2

昔日梦未散 2024-10-14 04:38:25

Numeric 的实例本身不是数字,而是提供算术运算的对象。例如,Numeric[Int] 类型的对象 num 可以将两个整数相加,如下所示: num.plus(3, 5) 结果这个运算的结果是整数 7。

对于整数来说,这是非常微不足道的。但是,对于所有基本数字类型,都有一个Numeric隐式实例可用。如果您定义自己的数字类型,则可以提供一种。

因此,您应该保留 A 的边界,并添加一个 Numeric[A] 类型的隐式参数,用它来进行计算。像这样:

def **[A](l:List[A],m:List[A])(implicit num:Numeric[A])=l.zip(m).map({t=>num.times(t._1, t._2)})

当然,num.times(a,b) 看起来不如 a*b 优雅。在大多数情况下,人们可以接受这一点。但是,您可以将值 a 包装在支持运算符的 Ops 类型的对象中,如下所示:

// given are: num:Numeric[A], a:A and b:A
val a_ops = num.mkNumericOps(a)
val product = a_ops * b

由于方法 mkNumericOps 已声明为 >隐式,您也可以导入它并隐式使用它:

// given are: num:Numeric[A], a:A and b:A
import num._
val product = a * b

The instance of Numeric is not a number itself, but it is an object that offers operations to do the arithmetic. For example, an object num of type Numeric[Int] can add two integers like this: num.plus(3, 5) The result of this operation is the integer 7.

For integers, this is very trivial. However, for all basic numerical types, there is one implicit instance of Numeric available. And if you define your own numeric types, you can provide one.

Therefore, you should leave the bounds for A open and add an implicit parameter of type Numeric[A], with which you do the calculations. Like this:

def **[A](l:List[A],m:List[A])(implicit num:Numeric[A])=l.zip(m).map({t=>num.times(t._1, t._2)})

Of course, num.times(a,b) looks less elegant than a*b. In most of the cases, one can live with that. However, you can wrap the value a in an object of type Ops that supports operators, like this:

// given are: num:Numeric[A], a:A and b:A
val a_ops = num.mkNumericOps(a)
val product = a_ops * b

Since the method mkNumericOps is declared implicit, you can also import it and use it implicitly:

// given are: num:Numeric[A], a:A and b:A
import num._
val product = a * b
情何以堪。 2024-10-14 04:38:25

您还可以通过上下文绑定来解决此问题。使用 这个答案,你可以写:

def **[A : Numeric](l:List[A],m:List[A]) =
   l zip m map { t => context[A]().times(t._1, t._2) }

或者

def **[A : Numeric](l:List[A],m:List[A]) = {
   val num = context[A]()
   import num._
   l zip m map { t => t._1 * t._2 }
}

You can also solve this with a context bound. Using the context method from this answer, you can write:

def **[A : Numeric](l:List[A],m:List[A]) =
   l zip m map { t => context[A]().times(t._1, t._2) }

or

def **[A : Numeric](l:List[A],m:List[A]) = {
   val num = context[A]()
   import num._
   l zip m map { t => t._1 * t._2 }
}
~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文