关于 scala.math.Integral 的问题

发布于 2024-10-28 00:35:02 字数 330 浏览 2 评论 0 原文

mkNumericOps 和 mkOrderingOps 的作用是什么rel="nofollow">scala.math.Integral 做什么以及我们如何使用它们?

据我所知,函数和对象方法可以被声明为隐式并用于隐式转换。但是我不明白为什么特征方法被声明为隐式

顺便说一句,类方法也可以被声明为隐式吗?

What do methods mkNumericOps andmkOrderingOps of scala.math.Integral do and how can we use them?

I understand that functions and object methods can be declared implicit and used for implicit conversion. However I do not understand why traits methods are declared implicit.

BTW, can class methods be declared implicit too?

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

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

发布评论

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

评论(1

旧时模样 2024-11-04 00:35:02

首先,让我们看看它们的声明:

implicit def mkNumericOps (lhs: T): IntegralOps
implicit def mkOrderingOps (lhs: T): Ops

它们是隐式的,这意味着它们的目标是提供一些自动值或转换。请注意,它们都从 T 转换为其他类型,其中 T 是特征的类型参数:Integral[T]

因此,如果您有 Integral[Int],那么 mkNumericOps 将为您提供从 IntIntegralOps 的自动转换。这意味着您将能够在 Int(或任何 类型)上调用来自 IntegralOpsOps 的方法。积分)。

现在,让我们看看这些方法是什么:

def % (rhs: T): T
def * (rhs: T): T
def + (rhs: T): T
def - (rhs: T): T
def / (rhs: T): T
def /% (rhs: T): (T, T)
def abs (): T
def signum (): Int
def toDouble (): Double
def toFloat (): Float
def toInt (): Int
def toLong (): Long
def unary_- (): T

这些方法来自 IntegralOps,它扩展了 Ops。关于它们的一个有趣的事情是,它们中的许多已经在 Int 上定义了!那么,如何以及为何使用它们呢?这里有一个例子:

def sum[T](list: List[T])(implicit integral: Integral[T]): T = {
    import integral._   // get the implicits in question into scope
    list.foldLeft(integral.zero)(_ + _)
}

因此,给定任何类型 T ,其中有一个隐式可用的 Integral[T] ,您可以将该类型的列表传递给 sum.

另一方面,如果我将方法专门用于 Int 类型,那么我可以在不使用 Integral 的情况下编写它。另一方面,我无法编写适用于 IntLong 以及 BigInt 的东西,因为它们不共享共同点定义方法 + 的祖先(更不用说“零”了)。

上面的 foldLeft 实际上可以翻译为:

list.foldLeft(integral.zero)((x, y) => mkNumericOps(x).+(y))

First, let's see their declaration:

implicit def mkNumericOps (lhs: T): IntegralOps
implicit def mkOrderingOps (lhs: T): Ops

The fact that they are implicit means their goal is to provide some automatic value or conversion. Note that they both convert from T to some other type, where T is the type parameter of the trait: Integral[T].

So, if you have Integral[Int], then mkNumericOps will give you an automatic conversion from Int to IntegralOps. That means you'll be able to call methods from IntegralOps or Ops on an Int (or whatever it is the type of your Integral).

Now, let's see what methods are these:

def % (rhs: T): T
def * (rhs: T): T
def + (rhs: T): T
def - (rhs: T): T
def / (rhs: T): T
def /% (rhs: T): (T, T)
def abs (): T
def signum (): Int
def toDouble (): Double
def toFloat (): Float
def toInt (): Int
def toLong (): Long
def unary_- (): T

These are from IntegralOps, which extends Ops. An interesting thing about them is that many of them are already defined on Int! So, how and why one would use them? Here's an example:

def sum[T](list: List[T])(implicit integral: Integral[T]): T = {
    import integral._   // get the implicits in question into scope
    list.foldLeft(integral.zero)(_ + _)
}

So, given any type T for which there's an Integral[T] implicitly available, you can pass a list of that type to sum.

If, on the other hand, I made my method specific for the type Int, I could write it without Integral. On the other hand, I can't write something that will work for both Int and Long and BigInt, because they do not share a common ancestor defining the method + (much less a `zero´).

The foldLeft above is effectively translated as this:

list.foldLeft(integral.zero)((x, y) => mkNumericOps(x).+(y))
~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文