小编Rui*_*ves的帖子

我需要一种方法来强制抽象类中的方法,使其具有被调用对象的具体类的返回类型.最常见的示例是copy()方法,我目前正在使用基于抽象类型的方法:

abstract class A(id: Int) {
  type Self <: A
  def copy(newId: Int): Self
}

class B(id: Int, x: String) extends A(id) {
  type Self = B
  def copy(newId: Int) = new B(newId, x)
}

class C(id: Int, y: String, z: String) extends A(id) {
  type Self = C
  def copy(newId: Int) = new C(newId, y, z)
}

我已经看到了许多方法,包括这个伟大答案中的方法.但是,它们都没有真正强制实现返回自己的类型.例如,以下类有效:

class D(id: Int, w: String) extends A(id) {
  type Self = A
  def …

我正在尝试为ElemScala中的现有类提供扩展方法.但是,我也希望任何操作都可用M[Elem],只要Scalaz Functorfor M在范围内.行为总是通过使用将操作应用于仿函数map.

import scalaz._
import Scalaz._

class Elem

implicit class Ops[F[_]: Functor, A <% Elem](self: F[A]) {
  def foo = self.map(_ => "bar")
}

val elem = new Elem

// TODO (nice to have): can we avoid this "explicit implicit" conversion?
implicit def idOps[A <% Elem](self: A) = new Ops[Id, A](self)

elem.foo                        // bar
Option(elem).foo                // Some(bar)
List(elem).foo                  // List(bar)

我想进一步让我的扩展方法可用于任意深度的仿函数,例如List[Option[Elem]]和Option[Option[Option[Elem]]].我能够为Ops两个仿函数的组合写一个隐含的提供,但是我无法将它推广到任意嵌套深度:

// TODO: can we …

我有一个小的Mesos集群,我正在使用Marathon来管理一组长期运行的服务,每个服务具有可变数量的实例.

我希望能够根据业务需求启动新节点或终止其中一些节点.但是,当终止节点时,我意识到存在一个潜在的问题:当我关闭Mesos从站时,会发生某些服务的实例数暂时低于定义的数量minimumHealthCapacity.例如,如果要停止的机器正在运行仅具有一个实例的服务,则可能导致一些停机.

请考虑以下简化方案:节点1正在运行服务A,节点2正在运行服务B而节点3正在运行服务C. minimumHealthCapacity对于所有服务都是1.我想终止节点1并且只留下2和3运行.我不希望服务A停机.预期行为的一个例子是将服务A扩展到2然后安全地终止节点1.

我该怎么做才能确保没有服务低于minimumHealthCapacity？

理想情况下,我会有一个滚动更新启发过程 - 替换是在单独的机器中启动,然后终止要关闭的机器中的服务.我希望至少有一个自动化的过程来做到这一点,所以缩小是一个简单的脚本.我没有要求花费这么多时间,即只有在我确定Marathon迁移完成并成功之后我才能关闭Mesos奴隶.

我正在处理一个包含许多子项目的庞大项目,其中一些项目有自己的子项目.最重要的是,我希望它们中的一些是动态的 - 考虑List到项目构建中的某个地方,我想为每个元素创建一个项目.

出于这些原因,必须lazy val为每个项目定义一个build.sbt非常麻烦.还有其他方式来声明项目,比如addProject我们可以在任何地方调用的类似方法吗？是否有一些SBT插件有助于此？

我试图理解为什么Scala编译器不能推断出对路径依赖类型的以下限制:

trait MyTrait
class MyTraitImpl extends MyTrait
trait MyTrait2[A <: MyTrait] {
  type MyTraitType = A
}
class MyTrait2Impl[A <: MyTrait] extends MyTrait2[A]

val obj: MyTrait2[_] = new MyTrait2Impl[MyTraitImpl]

def myMethod[A <: MyTrait](t2: MyTrait2[A]) = println("Hi!")

myMethod[obj.MyTraitType](obj)
// <console>:14: error: type arguments [obj.MyTraitType] do not conform to method myMethod's type parameter bounds [A <: MyTrait]
//               myMethod[obj.MyTraitType](obj)

对我来说,直观地说,MyTraitType除了a的子类之外,不能是其他任何东西MyTrait,因为绑定是正确A的MyTrait2.如果有,你能给我一个例子或指出我这个代码片段错误的地方吗？

如果这是Scala编译器限制,有人能告诉我使用类型系统实现这一目的吗？注意:

• 我没有MyTrait物品,也没有物品myMethod;
• 我不需要myMethod知道具体的类型A; 它需要知道的是A它是一个子类型, …