我习惯于从这样的特征继承:
trait A
trait B extends A
但最近我偶然发现它也有可能<::
trait A
trait B <: A
为什么？动机是什么？(不想听到它在规格中的记录.)当一个班级发挥作用时是不可能的.
虽然这按预期工作:
trait A
trait B extends A
object C extends A with B
以下产量illegal cyclic reference involving trait B:
package cyclictest {
trait A
trait B extends A
}
package object cyclictest extends A with B
那里发生了什么？
我试图建立一个简单的服务器/客户端akka(使用Akka 2.0.3)应用程序,但它无法连接.这里预先是基本代码:
import com.typesafe.config.ConfigFactory
import akka.actor.Actor
import akka.actor.ActorSystem
import akka.actor.Props
class Server extends Actor {
def receive = {
case s: String => println("Got " + s)
}
}
val serverSystem = ActorSystem("server", ConfigFactory.load(ConfigFactory.parseString("""
akka {
actor {
provider = "akka.remote.RemoteActorRefProvider"
}
remote {
transport = "akka.remote.netty.NettyRemoteTransport"
netty {
hostname = "localhost"
port = 5678
}
}
}
""")))
val server = serverSystem.actorOf(Props[Server], name = "server")
Thread.sleep(500)
println("started")
Thread.sleep(500)
val clientSystem = ActorSystem("client", ConfigFactory.load(ConfigFactory.parseString("""
akka {
actor {
provider = …我经常更改编辑器的字体大小.那么有人知道一个快捷键吗？到目前为止,我只需点击几下即可使用菜单:首选项 - >颜色和字体 - >基本 - >文本字体.可以使用CTRL+ MouseWheel很好...
请考虑以下代码:
class A { def print = println("A") }
class B extends A { override def print = println("B") }
def foo(implicit a: A) = a.print
def bar(implicit a: A) = {
implicit val b = new B
foo
}
bar(new A) // B
我很奇怪,为什么呼吁foo在bar不提出一个ambiguous implicit values错误.当然
implicit val b: A = new B
会引起这个错误.为什么foo选择隐式b而非隐式a？或者甚至更一般:将采取什么规则？
编辑:
由于我与Ivan的评论 - 我想澄清:如果我以与隐式方法参数相同的方式命名本地隐式val,我会知道我的问题的答案.
def bar(implicit a: A) = {
implicit val a …为什么不应用以下隐式方法？并且我如何实现自动将实例转换为具有隐含范围X的实例.YConversion[X,Y]
trait Conversion[X, Y] {
def apply(x: X): Y
}
implicit object Str2IntConversion extends Conversion[String, Int] {
def apply(s: String): Int = s.size
}
implicit def convert[X, Y](x: X)(implicit c: Conversion[X, Y]): Y = c(x)
val s = "Hello"
val i1: Int = convert(s)
val i2: Int = s // type mismatch; found: String required: Int
给出以下最小代码:
package object MyPackage {
case class Pimp(private val i: Int) extends AnyVal
}
SBT(0.13.8)抱怨:
[warn] sbt-api: Unhandled type class scala.reflect.internal.Types$MethodType : ($this: myPackage.package.Pimp)Int
我的构建文件大致如下:
Project("sbtissue", file("sbtissue")).settings(scalaVersion := "2.11.6")
将源文件中的相关行更改为:
class Pimp(private val i: Int) extends AnyVal
要么:
case class Pimp(i: Int) extends AnyVal
编译时不会发出警告.我该怎么做才能防止这种警告？
相关:https://groups.google.com/forum/#!topic/simple-build-tool/KWdg4HfYqMk
trait A {
trait B {
def foo: A.this.B = new B{}
def bar: A#B = foo
def baz: A.this.B = bar // type mismatch; found : A#B required: A.this.B
}
}
我是对的,这A.this.B是一种路径依赖型？!(这是我到目前为止的理解)上面的例子是否意味着类型A.this.B 是一个子类型 A#B？(如果是的话,我猜不同的是,一个实例A.this.B有一个A对比实例的引用A#B没有？)有没有人知道一个有启发性的解释来解决我对这两种类型的困惑？
最近我从scala演员切换到akka演员,但注意到akka演员使用ActorRef而不是实例对象:
val actorRef: ActorRef = Actor.actorOf(new MyActor)
所以我尝试过:
val myActor = new MyActor
val actorRef: ActorRef = Actor.actorOf(x)
...同时拥有:1)ActorRef发送消息和2)MyActor调用方法.
但我得到了:
akka.actor.ActorInitializationException: ActorRef for instance of actor [MyActor] is not in scope.
所以我的问题是:我如何获得一个我可以调用的实例(某种类型)ActorRef- 像!AND这样的方法来自MyActor实例的方法？
假设我有一个类型类:
trait ToString[T] {
def toString(t: T): String
}
以下皮条客:
implicit def ToStr[T: ToString](t: T) = new {
def toStr: String = implicitly[ToString[T]] toString t
}
现在让我们测试一下:
class A
implicit object AToString extends ToString[A] {
def toString(a: A) = "A"
}
(new A).toStr // A
很好,到目前为止.但是,如果我介绍了一个子类B的A:
class B extends A
(new B).toStr // could not find implicit value for evidence parameter of type ToString[B]
所以我尝试过:
implicit def foo[X: ToString, Y <: X]: ToString[Y] = new ToString[Y] …正如问题所说我正在尝试以下(不编译):
object O {
def apply(i: Int): Boolean = i % 2 == 0
}
val f: Int => Boolean = O
所以我尝试了这个:
implicit def apply2Fct[A,B](applier: { def apply(a: A): B }) = {
new Function[A,B] { def apply(a: A): B = applier(a) }
}
但是编译器抱怨"结构细化中的参数类型可能不会引用在该细化之外定义的抽象类型".
编辑:
由于Jean-Philippe Pellet的回答,我不得不提到我不能分别O延长.Function[A,B]Function[Int,Boolean]
作为我的其他问题的后续内容,请参阅代码中的注释/问题:
case class Implicit(name: String)
def foo(implicit i: Implicit = null) = println(Option(i))
def bar1(implicit i: Implicit) {
foo // prints None
implicit val i = Implicit("J") // Why is call to foo above affected although this line comes after?
foo // prints Some(Implicit(I))
}
def bar2(implicit i: Implicit) {
foo // prints None
implicit val i = null
implicit val j = Implicit("J")
foo // prints None // Why? Should raise ambiguous implicits or at least choose …我该如何进行以下工作？
trait T {
type I <: T
def apply(i: I): I
}
class Foo[T0 <: T](t: T0) {
def bar(x: T0) = t(x)
}
implicit def tofoo[T0 <: T](t: T0) = new Foo(t)
该bar行产生错误:
type mismatch; found : x.type (with underlying type T0) required: Foo.this.t.I
(有人可能会说,为什么皮条客和具有bar做同样的apply在T,但it's因为我减少了问题,在我工作的代码我有一个序列[T]作为一个参数bar.)
编辑:
由于@AlexeyRomanov的答案,我展示了一个例子(也从工作代码中减少了)也应该有效:
trait T {
type I <: T
def apply(i: I): I
}
class Foo[T0 <: T { type I = T0 …