小编0__*_*0__的帖子

比方说我有这个特点

trait Ctx[C, V[_]]

我无法构造任何采用Ctx的方法签名,其中第二个类型参数未指定(通配符).例如:

def test(c: Ctx[_, _]) = ()

不编译("error: _$2 takes no type parameters, expected: one").我也不能这样做

def test(c: Ctx[_, _[_]]) = ()

("error: _$2 does not take type parameters").我错过了什么？

在Scala 2.10中,MurmurHash由于某种原因被弃用,说我MurmurHash3现在应该使用.但是API是不同的,并且没有有用的scaladoc用于MurmurHash3- >失败.

例如,当前代码:

trait Foo {
  type Bar
  def id: Int
  def path: Bar

  override def hashCode = {
    import util.MurmurHash._
    var h = startHash(2)
    val c = startMagicA
    val k = startMagicB
    h = extendHash(h, id, c, k)
    h = extendHash(h, path.##, nextMagicA(c), nextMagicB(k))
    finalizeHash(h)
  }
}

我该如何使用MurmurHash3呢？这需要一个快速的操作,最好不分配,所以我不希望建立一个Product,Seq,Array[Byte]或whathever MurmurHash3似乎为我提供.

它让我发疯,字符串插值有一些特殊的规则,不允许从a + b样式直接转换:

// ok
def test(f: java.io.File) = {
  val abs = f.getAbsoluteFile
  val isF = abs.isFile
  "select " + (if (isF) "file" else "folder") +"\"" + abs.getName +"\" of folder"
}

// fail
def test(f: java.io.File) = {
  val abs = f.getAbsoluteFile
  val isF = abs.isFile
  s"select ${if (isF) "file" else "folder"} \"${abs.getName}\" of folder"
}

然后有一个可爱的错误消息:

<console>:38: error: value $ is not a member of String
         s"select ${if (isF) "file" else "folder"} \"${abs.getName}\" of folder …

我想利用Scala的类型系统来约束系统中的操作,在该系统中存在对某些值的版本化引用.这一切都发生在一些附加Ctx了版本类型的事务上下文中V.现在有一个Factory创建引用变量.它们是通过附加它们的创建版本(类型参数V1)创建的,对应于调用工厂的上下文版本.

现在想象一些代码试图在更高版本中访问该引用,即使用不同的代码Ctx.我想要实现的是禁止Ref在与创建版本不匹配的任何版本(Ctx的V类型字段)中调用访问权限,但允许您通过一些返回新的替换机制来解析引用Ref在当前版本中可以访问的视图.(如果substitute使用无效的上下文调用它是可以的,例如一个比Refs 更旧的V1- 在这种情况下可能抛出运行时异常)

这是我的尝试:

trait Version

trait Ctx {
  type V <: Version
}

object Ref {
  implicit def access[C <: Ctx, R, T](r: R)(implicit c: C, view: R => Ref[C#V, T]): T =
    view(r).access(c)

  implicit def substitute[C <: Ctx, T](r: Ref[_ <: Version, T])
                                      (implicit c: C): Ref[C#V, T] = …

-unchecked启用时,为什么以下内容不会产生警告:

object Order {
   sealed trait EntryOption
   case object EmptyEntry extends EntryOption
   trait Entry extends EntryOption

   def isEmpty(a: EntryOption): Boolean = a match {
      case EmptyEntry => true
//    case _: Entry   => false
   }
}

在Scala 2.8.0 之前,我似乎遇到了完全相同的问题,没有足够的答案.

编辑

@Jed对我来说,仅对非抽象类发出警告是没有意义的Entry.考虑以下情况:

trait Order {
  sealed trait EntryOption
  case object EmptyEntry extends EntryOption
  abstract sealed class Entry extends EntryOption

  def isEmpty(a: EntryOption): Boolean = a match {
    case EmptyEntry => true
 // case _: Entry …

我想放宽对特征类型参数的约束,而是将它们以证据参数的形式强加给方法.鉴于一些骨架设置:

trait State[Repr]
object Observer {
  def apply[Repr <: State[Repr]](reader: Reader[Repr]): Observer[Repr] = 
    new Observer[Repr] {}
}
trait Observer[A]
trait Reader  [A]

这有效:

trait StateX[Repr <: StateX[Repr]] extends State[Repr] { 
  protected def reader: Reader[Repr]
  def observe: Observer[Repr] = Observer(reader)
}

而这不是:

trait StateY[Repr] extends State[Repr] { 
  protected def reader: Reader[Repr]
  def observe(implicit ev: Repr <:< State[Repr]): Observer[Repr] = Observer(reader)
}

随着消息"inferred type arguments [Repr] do not conform to method apply's type parameter bounds [Repr <: State[Repr]]".由于证据ev表明这种构象,我想知道如何 …

看着http://www.scala-sbt.org/release/docs/Howto/scaladoc.html有给了scaladoc选择这样的例子-groups和-implicits.

有关scaladoc(2.10)选项的信息在哪里？就像一个手册页.我似乎无法找到它,既不是docs.scala-lang.org,也不是wiki.scala-lang.org ......

除了由sbt管理之外我不使用Scala安装,所以我真的想要一个在线资源.

让我们说我foo从版本1.0.0到库创建了我的库的二进制兼容更新1.0.1.图书馆foo通过Maven发布.

我是否可以使用此次要版本更新来同时修复依赖项的次要版本foo？例如,版本1.0.0正在使用scalaVersion := "2.10.1".我可以将其更改为scalaVersion := "2.10.3"foo 1.0.1,还是会导致麻烦？

假设我foo在另一个项目中使用

"mygroup" %% "foo" % "1.0.+"

我想将F有界多态转换为抽象类型成员.

trait FBoundedMovable[Self <: FBoundedMovable[Self]] {
  def moveTo(pos: Vect2): Self
}

至

trait Movable { self =>
  type Self <: (Movable { type Self = self.Self })

  def moveTo(pos: Vect2): Self
}

到现在为止还挺好.

让我们定义一个实例:

case class Ship(pos: Vect2) extends Movable {
  type Self = Ship

  def moveTo(pos: Vect2) = copy(pos = pos)
}

并尝试使用它:

// [error]  found   : a.Self
// [error]  required: A
  def move[A <: Movable](a: A, to: Vect2): A = a.moveTo(to)

F有界版本工作正常.

def moveF[A <: FBoundedMovable[A]](a: A, to: …

Scastie版本

有了这个基础结构:

trait Pat[A]
object Pat {
  def apply[A](elems: A*): Pat[A] = ???
}

implicit class PatOps[A](p: Pat[A]) {
  def ++ (that: Pat[A]): Pat[A] = ???

  def bubble: Pat[Pat[A]] = ???

  def grouped(size: Pat[Int]): Pat[Pat[A]] = ???
}

implicit class PatPatOps[A](p: Pat[Pat[A]]) {
  def map[B](f: Pat[A] => Pat[B]): Pat[Pat[B]] = ???

  def flatMap[B](f: Pat[A] => Pat[B]): Pat[B] = ???

  def flatten: Pat[A] = ???
}

可以写下以下的理解:

trait Test1 {
  val lPat = Pat(1, 2, 3)
  val xs = for { …