我在这个链接中查看了PartialFunction的文档:
trait PartialFunction[-A, +B] extends (A) ? B
也许有人可以帮助澄清通用声明中加号和减号的重要性？
我理解scala中的协方差和逆变.协方差在现实世界中有很多应用,但除了相同的函数旧例子之外,我无法想到任何逆变量应用.
有人可以了解现实世界的contravariance使用范例吗？
我相信人们可以将协方差(至少对象来说)定义为"使用较窄(子)类型的值代替某种较宽(超级)类型的值的能力",并且这种相反性恰好相反.这个.
显然,Scala函数是函数[-A1,...,+ B]的实例,用于逆变参数类型A1等,以及协变返回类型B.虽然这对于函数的子类型很方便,但上述定义不应该意味着我可以传递任何超类型作为参数？
请告诉我哪里弄错了.
在Java中我可能会这样做:
class MyClass {
private List<? extends MyInterface> list;
public void setList(List<MyImpl> l) { list = l; }
}
......假设(MyImpl implements MyInterface当然).
使用？时,Scala中的模拟是Buffer什么？
import java.lang.reflect._
import scala.collection.mutable._
class ScalaClass {
val list:Buffer[MyInterface] = null
def setList(l: Buffer[MyImpl]) = {
list = l
}
}
这(当然)不编译 - 但是如何list以这样的方式声明变量呢？
编辑 ; 我要补充一点.显然,这与Java中的泛型在T中从不协变这一事实有关,而在Scala中,它们可以是协变的,也可以不是协变的.例如,Scala类List在T中是协变的(并且必然是不可变的).因此以下将编译:
class ScalaClass {
val list:List[MyInterface] = null
def setList(l: List[MyImpl]) = {
list = …所有读完Scala协方差/逆变问题及其答案由Daniel Spiewak提供,以及"Scala编程"一书的第19.3-19.7节,我对Function1 [-A,+ B]的定义有另一种疑惑:为什么它的第一种类型参数是逆变的吗？我有一个原因,就是这种类型参数保证了当有多种情况时,子类型总是比超类型更早出现,同时,子类型"是一种"超类型.例如:
class A
class B extends A
class C extends B
scala> val withDefault: A => B = {
| case x:B => new B
| case x:A => new B }
withDefault: A => B = <function1>
这里,(1)case x:B早于case x:A,(2)功能1 [A,B] <:功能1 [B,B]并且必须有其他原因？任何消息将不胜感激!
我试图写一个不可变的Matrix[A]类.我希望类被协变的A,但是当我把+前面A的编译器开始抱怨在类中的一些操作.
以下是我的Matrix类的相关子集(实际类比以下子集大5倍):
class Matrix[+A] private(val contents: Vector[Vector[A]])(implicit numericEv: Numeric[A])
extends ((Int, Int) => A) with Proxy {
import numericEv._
import Prelude._
// delegate `equals` and `hashCode` implementations to `contents`
override def self = contents
val nRows: Int = contents.length
val nColumns: Int = contents(0).length.ensuring { len =>
contents.forall(_.length == len)
}
def dimensions = (nRows, nColumns)
def isSquare = nRows == nColumns
def hasSameOrderAs[B : Numeric](that: Matrix[B]) = this.dimensions == …我正在尝试理解Scala中的协方差,但我找不到任何帮助我解决这个问题的例子.我有这个代码:
class GenericCellImm[+T] (val x: T) {}
它编译得很好,但是当我使用它时
class GenericCellMut[+T] (var x: T) { }
它没有编译.为什么我在写这段代码时不能使用var(但我可以使用val)？我该如何解决？这里也是类似的情况
abstract class Sequence[+A] {
def append(x: Sequence[A]): Sequence[A]}
问题是什么？
通过这篇关于Parser Combinators的信息性很好的文章阅读,我看到了这段代码:
class DisParser[+A](left: Parser[A], right: Parser[A]) extends Parser[A] {
def apply(s: Stream[Character]) = left(s) match {
case res: Success => res
case _: Failure => right(s)
}
}
当我尝试编译此代码时,我得到:
Parser.scala:19: error: class Success takes type parameters
case res: Success => res
^
one error found
鉴于签名Parser:
case class Success[+A](value: A, rem: Stream[Character]) extends Result[A]
如何更改case res: Success => res线条以提供Success正确的类型参数？
在scala中,Option类被声明为
sealed abstract class _Option[+A]
case object _None extends _Option[Nothing] {}
final case class _Some[+A](x: A) extends _Option[A] {}
什么是[+A]？为什么不[A]呢？可能[-A]是它意味着什么？
对不起,如果它是重复但我找不到答案的SO.
我想用 mutable.HashMap[] 的 val 扩展一个类，如下所示：
class Father
class Son extends Father
class C1{
val m = new mutable.HashMap[Int, Father]()
}
class C2 extends C1{
override val m = new mutable.HashMap[Int, Son]()
}
并得到一个错误：
错误：(19, 16) 覆盖类型为 scala.collection.mutable.HashMap[Int,ScalaByExample.Father] 的类 C1 中的值 m；值 m 具有不兼容的类型覆盖 val m = new mutable.HashMapInt, Son
我发现它immutable.HashMap是协变的，但它mutable.HashMap是不变的。如果替换mutable.HashMap为immutable.HashMap.
所以我的两个问题是：
如何使用 mutable.HashMap 使其工作？
为什么scala的作者要这样设计HashMap？