我试图创建一个与依赖类型_ >: a.type相关的类型别名。
Scala编译器报告了一个我不理解的错误:
scala> def foo[A](a: A) = {
| type F = Function1[_ >: a.type, Unit]
| }
<console>:12: error: type mismatch;
found : a.type (with underlying type A)
required: AnyRef
Note that A is unbounded, which means AnyRef is n
在成功匹配父类之后,是否可以让Scala在类层次结构中保持模式匹配?例如,我期望下面的代码打印1和2,但是在将S与T进行匹配之后,Scala不会继续匹配下一个案例,因此永远不会到达下一个案例。
class T
class S extends T
new S match {
case _: T => println(1)
case _: S => println(2)
}
scala中List类中productiterator方法的用例是什么
val l1 = List(1.1, 2.2, 3.3)
val it = l1.productIterator
//I get the following result
res0: Double = 1.1
res1: List[Double] = List(2.2, 3.3)
//but I can get the same using head and tail
l1.head
1.1
l1.tail
List(2.2, 3.3)
来自
参与者通过扩展Actor基本特性和实现receive方法来实现。receive方法应该定义一系列case语句(其类型为PartialFunction[Any, Unit]),使用标准Scala模式匹配定义Actor可以处理哪些消息,以及应该如何处理消息的实现。
代码:
class MyActor extends Actor {
val log = Logging(context.system, this)
def receive = {
case "test" ⇒ log.info("received test")
cas
最近我一直在使用复合类型,最近我尝试了以下代码:
import scala.reflect._
object Main {
def main(args: Array[String]) {
val a1 = classTag[Int with String with Double].newArray(3)
println(a1.mkString(" "))
val a2 = classTag[String with Int with Double].newArray(3)
println(a2.mkString(" "))
我在玩Scala代码,遇到了一条我不太明白的错误信息。下面是我的代码
val ignoredIds = Array("one", "two", "three")
def csNotify(x : Any): String = {
case org: String if !ignoredIds.contains(x) =>
println( s" $x should not be here")
"one"
case org : String if ignoredIds.conta
我的问题是:
这是什么警告?没有reflect.runtime.universe.TypeRef的类型参数
为什么这会被抛到方法调用arg而不是asInstanceOf上。
控制台输出:
Welcome to Scala version 2.10.0 (Java HotSpot(TM) Client VM, Java 1.6.0_35).
Type in expressions to have them evaluated.
Type :help for more information.
scala> import reflect.runtime.{universe
现在学习Scala,特别是学习模式匹配,我用Scala编写了这个简单的阶乘方法:
def factorial(n : Int) : Int = {
if(n <= 1)
1
else
n * factorial(n -1)
}
然后,我想,我可以使用模式匹配,并写道:
def fact(n : Int) : Int = n match {
case 0 => 1
case n => n * fact(n -1)
}
但是我认为模式匹配的重点是对数据进行排序,为什么我需要在阶乘之类的东西上使用这个呢?
非常感谢。
我有一个带有参数的类型别名,我想从一个方法返回不同参数类型的实例:
type TC[T] = (ClassTag[T], Option[T])
def gen(x: Int): TC[_] = x match {
case 0 => (classTag[Int], Option[Int](0))
case _ => (classTag[String], Option[String](""))
}
这不起作用,给我带来了错误:
错误:类型错配;已找到:(scala.reflect.ClassTag_ >:Int,OptionAny)必需: TC (s
我可以用开关大小写来匹配枚举中的模式吗?
我试过了
import scala.annotation.switch
object Foo extends Enumeration {
val First = Value
val Second = Value
val Third = Value
}
object Main {
def foo(x: Foo.Value) = (x: @switch) match {
case Foo.First => 1
case Foo.Second => 2
case Foo.Third => 3
可能重复:
我将自我注释理解为对编译器的承诺,程序员在其中显示一个特征将与带注释的特性混在一起。例如:
scala> trait X
defined trait X
scala> trait Y { this: X => }
defined trait Y
scala> new Y {}
<console>:10: error: illegal inheritance;
self-type Y does not conform to Y's selftype Y with X
new Y {}
我试图在Scala中创建一个非常简单的二叉树,用于数据存储和遍历。
现在我有:
trait Tree
case class Node(left: Tree, value: String, right: Tree) extends Tree
我的问题:
如何还包括指向父级的指针?
我可以用任何方式左右点为空吗?还是根节点的父指针?
我怎么才能真正穿越这棵树呢?
更新节点的值容易吗?
我知道这是一种愚蠢的问题感觉,但现在.我是否可以定义一个类型,它是另一个类型的元素的子集?下面是一个简化的例子。
scala> class Even(i: Int) {
| assert(i % 2 == 0)
| }
defined class Even
scala> new Even(3)
java.lang.AssertionError: assertion failed
这是一个运行时检查。我是否可以定义一种类型,以便在编译时检查此类型?例如,输入参数i是否总是偶数?
我知道Scala不支持“并集类型”,但是交集类型呢?
简而言之,我想要一个这样的函数:
def intersect[A,B,C](a: A, b: B): C = ??? // a & b
或者一种方法:
class A {
def intersect[B, C](b: B): C = ??? // this & b
}
A和B共享一个确保intersect操作有效性的公共超类,并且C将是A或B交叉处的类型。
在我的用例中,A或B表示变量或常量(相同类型)。我想在类方面区分一个常量和一个变量和一个单独的域。如果我尝试将一个集合与一个值相交,则返回该值(或者返回空集/如果
构造phoneVector:
val phoneVector = (
for (i <- 1 until 20) yield {
val p = killNS(r.get("Phone %d - Value" format(i)))
val t = killNS(r.get("Phone %d - Type" format(i)))
if (p == None) None
else
if (t == None) (p,"Main") else (p,t)
在我与一位朋友在代码评审期间进行的友好交谈中,我们注意到代码中有很多:
unknownTypeVal match {
case asStr: String => //DO SOMETHING FOR STRING
case asInt: Integer => //DO SOMETHING FOR Integer
case asMyOwnClass: MyOwnClass => //DO SOMETHING FOR MyOwnClass
}
最初由返回Any或Option的方法产生的问题,没有办法删除它,因为我们使用库作为XPath和JSONPath,它
在尝试理解一些代码时,我遇到了一些奇怪的行为,并将其简化为:
在匹配中引入类型参数不起作用:
scala> Some(0) match { case _: Some[A] => 0 }
<console>:8: error: not found: type A
Some(0) match { case _: Some[A] => 0 }
^
但是,如果我用小写的话,它会:
scala> Some(0) match { case _: Some[a
如果有可能以某种方式扩展Scala枚举值类型,那么一种树结构就更好了。我的意思是这样的:
示例只是伪代码!
object SomeSubEnum extends Enumeration {
type SomeSubEnum = Value
val SubA, SubB, SubC = Value
}
object SomeTopEnum extends Enumeration {
type SomeTopEnum = Value
val TopA = Value("TopA", Subs = List(SomeSubEnum.SubA, SomeSubEn
我尝试使用标签类型从黄玉,以加强类型的安全性。
我遇到了一个我不明白的警告和错误。
你能解释我两个人吗?
以下是控制台的输出:
scala> sealed trait PostId
defined trait PostId
scala> def PostId(l: Long) : Long @@ PostId = Tag[Long, PostId](l)
PostId: (l: Long)scalaz.@@[Long,PostId]
warning: previously defined trait PostId is not a companion to method Post