看一下我的库的一些scala-docs,在我看来,值类中有一些不需要的噪音.例如:

implicit class RichInt(val i: Int) extends AnyVal {
  def squared = i * i
}

这引入了不必要的符号i:

4.i   // arghh....

那些东西出现在scala文档和IDE自动完成中,这实际上并不好.

那么......关于如何缓解这个问题的任何想法？我的意思是你可以使用,RichInt(val self: Int)但这不会让它变得更好(4.self,是吗？)

编辑:

在以下示例中,编译器是否擦除了中间对象？

import language.implicitConversions

object Definition {
  trait IntOps extends Any { def squared: Int }
  implicit private class IntOpsImpl(val i: Int) extends AnyVal with IntOps {
    def squared = i * i
  }
  implicit def IntOps(i: Int): IntOps = new IntOpsImpl(i)  // optimised or not?
}

object Application …

Scala 2.10引入了值类,您可以通过使类扩展来指定它们AnyVal.值类有许多限制,但它们的一个巨大优点是它们允许扩展方法而没有创建新类的惩罚:除非需要装箱,例如将值类放在数组中,它只是旧类加上一组将类作为第一个参数的方法.从而,

implicit class Foo(val i: Int) extends AnyVal {
  def +*(j: Int) = i + j*j
}

解开一些不比写i + j*j自己更贵的东西(一旦JVM内联方法调用).

不幸的是,SIP-15中描述值类的一个限制是

3. C的基础类型可能不是值类.

如果你有一个值类,你可以开始,比如说,作为一种提供类型安全单位而不需要拳击开销的方法(除非你真的需要它):

class Meter(val meters: Double) extends AnyVal {
  def centimeters = meters*100.0                // No longer type-safe
  def +(m: Meter) = new Meter(meters+m.meters)  // Only works with Meter!
}

那么有没有办法在Meter没有对象创建开销的情况下进行充实？SIP-15的限制防止了明显的限制

implicit class RichMeter(m: Meter) extends AnyVal { ... }

做法.

在有关Scala值类的文档中,提到有三种情况需要实际为实例分配一个值实例:

分配摘要

在以下情况下实际实例化值类:

1. 值类被视为另一种类型.
2. 值类被分配给数组.
3. 进行运行时类型测试,例如模式匹配.

编译器或语言功能中是否有设置,当需要实例化值类时会产生警告？

我正在寻求对基于价值的类的定义的一些澄清.我无法想象,最后一个要点(6)应该如何与第一个一起工作

• (1)它们是final和immutable(尽管可能包含对可变对象的引用)
• (6)它们在相等时可自由替换,这意味着在任何计算或方法调用中根据equals()交换任意两个x和y实例应该不会产生明显的行为变化.

Optional 就是这样一堂课.

Optional a = Optional.of(new ArrayList<String>());
Optional b = Optional.of(new ArrayList<String>());
assertEquals(a, b); // passes as `equals` delegated to the lists

b.get().add("a");

// now bite the last bullet
assertTrue(a.get().isEmpty()); // passes
assertTrue(b.get().isEmpty()); // throws

我读错了,还是需要更准确？

更新

伊兰的答案是有道理的(他们不再平等),但让我移动目标:

...
assertEquals(a, b); // now, they are still equal
assertEquals(m(a, b), m(a, a)); // this will throw
assertEquals(a, b); // now, they are equal, too

让我们定义一个有趣的方法m,它会做一些变异并再次撤消它:

int …

我正在尝试使用具有值类的房间实体：

@JvmInline
value class UserToken(val token: String)

和实体：

@Entity(tableName = TABLE_AUTH_TOKEN)
data class TokenEntity(
  @PrimaryKey val id: Int = 0,
  val token: UserToken
)

我收到以下错误：

error: Entities and POJOs must have a usable public constructor. You can have an empty constructor or a constructor whose parameters match the fields (by name and type).
public final class TokenEntity {
             ^

是否可以使用经济舱的房间？我找不到任何关于此的信息。谢谢

我正在为现有的Java库编写一组隐式Scala包装类(这样我就可以装饰该库以使Scala开发人员更方便).

作为一个简单的例子,让我们说Java库(我无法修改)有一个类,如下所示:

public class Value<T> {
    // Etc.
    public void setValue(T newValue) {...}
    public T getValue() {...}
}

现在让我们说我想用Scala风格的getter和setter 来装饰这个类.我可以使用以下隐式类来完成此操作:

final implicit class RichValue[T](private val v: Value[T])
extends AnyVal {
  // Etc.
  def value: T = v.getValue
  def value_=(newValue: T): Unit = v.setValue(newValue)
}

该implicit关键字告诉Scala编译器它可以将实例转换Value为RichValue隐式实例(前提是后者在范围内).所以现在我可以将其中定义的方法RichValue应用于实例Value.例如:

def increment(v: Value[Int]): Unit = {
  v.value = v.value + 1 …

我想将scala的值类应用于我的一个项目,因为它们使我能够丰富某些原始类型而没有很大的开销(我希望)并保持类型安全.

object Position {

  implicit class Pos( val i: Int ) extends AnyVal with Ordered[Pos] {

    def +( p: Pos ): Pos = i + p.i

    def -( p: Pos ): Pos = if ( i - p.i < 0 ) 0 else i - p.i

    def compare( p: Pos ): Int = i - p.i

  }
}

我的问题:每当我使用它们时,继承Ordered强制Pos对象的分配(从而引入很大的开销)吗？如果是这样的话:有没有办法绕过这个？

我在Excel中构建了一个简单的矩阵,其中包含一些字符值和一些数值(在Excel中设置的数据截图).我使用openxlsx包将其读入R中,如下所示:

library(openxlsx)
data <- read.xlsx('~desktop/data.xlsx)

之后我检查了课程:

sapply(data, class)
         x1         a         b          c
"character" "numeric" "numeric"  "numeric"

这正是我想要的.当我尝试转置矩阵,然后再次检查类时,我的问题出现了:

data <- t(data)

当我现在检查sapply时,所有值都是"character".为什么在移调时不保留类？

我知道value class在scala内联编译时的操作.

也许是这样的

case class A(i: Int) extends AnyVal {
   def +(that: A) = A(this.i + that.i)
} 
A(1) + A(2) // After compile it equals to 1 + 2 

但这对我来说似乎没什么大不了的.

它可能会提高性能,但是,

打电话this.i + that.i似乎没有那么慢i + i

为什么我们需要value classscala和任何用例???

在值类的规范中,它说:

值类只能扩展通用特征,不能自己扩展.一个普遍的特点是延伸的特质Any,只有defS作为成员,并不做任何初始化.通用特征允许值类的方法的基本继承,但它们会产生分配的开销.例如

trait Printable extends Any {
  def print(): Unit = println(this)
}
class Wrapper(val underlying: Int) extends AnyVal with Printable

val w = new Wrapper(3)
w.print() // actually requires instantiating a Wrapper instance

第一个问题

现在,我想借此意味着以下的(可能)不要求实例:

trait Marker extends Any
class Wrapper(val underlying: Int) extends AnyVal with Marker {
  def print(): Unit = println(this) //unrelated to Marker
}

val w = new …