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

我希望那会像往常那样直截了当

Console.out.println( "Test " + Console.RED + " RED " + Console.RESET )

但没有任何反应,相反,我看到了控制字符(例如"\033[31m").我在sbt(sbt run)和正常的IDEA运行配置运行中尝试了两个...

在Scala 2.9中为库类添加自定义方法(丰富或"皮条客")我不得不写这样的东西:

object StringPimper {
  implicit def pimpString(s: String) = new {
    def greet: String = "Hello " + s
  }
}

随着Scala 2.10的发布,我读到它引入了隐式类定义,从理论上讲,它是通过在返回匿名类对象的隐式方法中消除需要来简化上述任务.我以为这会让我写出来

implicit class PimpedString(s: String) {
  def greet: String = "Hello " + s
}

这对我来说看起来更漂亮.但是,这样的定义会导致编译错误:

`implicit' modifier cannot be used for top-level objects

通过将代码再次包装在对象中来解决:

object StringPimper {
  implicit class PimpedString(s: String) {
    def greet: String = "Hello " + s
  }
}

不用说,这几乎抵消了改善的意义.

那么,有没有办法把它写得更短？要摆脱包装器对象？

我实际上有一个MyApp.pimps所有皮条客都去的包(我没有太多,如果我有的话,我会使用一些单独的包)而且我厌倦了导入MyApp.pimps.StringPimper._而不是MyApp.pimps.PimpedString或MyApp.pimps._.当然,我可以将所有隐式类放在一个包装器对象中,但这意味着将它们全部放在一个文件中,这将是相当长的 - 非常难看的解决方案.

看一下我的库的一些scala-docs,在我看来,值类中有一些不需要的噪音.例如:

implicit class RichInt(val i: Int) extends AnyVal {
  def squared = i * i
}

这引入了不必要的符号i:

4.i   // arghh....

那些东西出现在scala文档和IDE自动完成中,这实际上并不好.

那么......关于如何缓解这个问题的任何想法？我的意思是你可以使用,RichInt(val self: Int)但这不会让它变得更好(4.self,是吗？)

编辑:

在以下示例中,编译器是否擦除了中间对象？

import language.implicitConversions

object Definition {
  trait IntOps extends Any { def squared: Int }
  implicit private class IntOpsImpl(val i: Int) extends AnyVal with IntOps {
    def squared = i * i
  }
  implicit def IntOps(i: Int): IntOps = new IntOpsImpl(i)  // optimised or not?
}

object Application …

所以我googl'ed了一点,但除了稀疏之外没有其他信息:

-Yrangepos                     Use range positions for syntax trees.

好.而且我知道如果我想在宏中捕获源片段,我需要使用它.

现在我的两个问题是:

• 为什么这不是默认开启？
• 使用它有任何副作用(例如增加类文件大小)？

我拼命想要解决以下问题:

trait Access[Res[_]] { def access[C]: Res[C] }

trait CList[C1, A] extends Access[CList[_, A]] // ?!

def test[C1, C2, A](c: CList[C1, A]): CList[C2, A] = c.access[C2]

scalac只是说:"error: illegal cyclic reference involving trait CList".我该怎么做这个编译？

所以,这听起来像是关于语言设计的一般问题,但我认为这里有一些具体的东西.具体来说,我感兴趣的是哪些技术挑战可以防止随之而来的kludgy代码普遍有用.

我们都知道"Scala的类型推断不如Haskell的那么好",并且有许多原因它不能很好,并且仍然可以完成Scala所做的所有事情.但是,在Scala编程足够长的时候,很明显的是,糟糕的类型推断并不是那么糟糕,而是指定一些常见类型所需的详细程度.那么,例如,在多态tail函数中,

def tail[A](ls: List[A]) =
    ls match {
        case Nil     => sys.error("Empty list")
        case x :: xs => xs
    }

为了使方法有用,需要显式命名一个类型参数; 没办法解决它.tail(ls: List[Any])不会起作用,因为Scala无法弄清楚结果类型是否与输入类型相同,即使对于人来说这是"显而易见的".

因此,受到这种困难的启发,并且知道Scala有时会对类型成员比使用类型参数更聪明,我写了一个List使用类型成员的版本:

sealed trait TMList {
    self =>
    type Of
    def :::(x: Of) = new TMCons {
        type Of = self.Of
        val head = x
        val tail = (self: TMList { type Of = self.Of })
    }
}
abstract class TMNil extends TMList
def ATMNil[A] = new TMNil { …

我认为这将正确使用Scala 2.10的新隐式类:

implicit case class IntOps(i: Int) extends AnyVal {
  def twice = i * 2
}

11.twice

显然不是:

<console>:13: error: value twice is not a member of Int
              11.twice
                 ^

我错过了什么(Scala 2.10.0-M6)？

说我有

lazy val foo = Project(
  id            = "foo",
  base          = file("foo")
)

lazy val bar = Project(
  id            = "bar",
  base          = file("bar")
  dependencies  = Seq(foo)    // only want that for `% "test"`....
)

如何更改bar,使其仅在测试范围取决于富？

我想尝试编写一个类型,其方法可以是同类的,并返回相同类型的值:

object SimpleTest {
  trait Foo extends Product with Serializable {
    type Self <: Foo
    def bar: Self
  }

  case class X() extends Foo {
    type Self = X
    def bar = this
  }

  case class Y() extends Foo {
    type Self = Y
    def bar = this
  }


  trait TC[A]

  implicit val tc: TC[Foo] = new TC[Foo] { }

  def tester[A: TC](x: Seq[A]) = "foo"

  // tester(Seq(X(), Y()))
}

不幸的是,注释掉的行调用tester失败并出现以下错误(Scala 2.10):

Error: could not find implicit value …

private[this] def与仅仅相比,写作在性能与噪声比方面是否有意义private def？我的理解是,使有关差别private[this] val过private val,因为前者允许scalac创建一个实际的领域.但也许因为def它没有区别？最后,怎么样private[this] var？

有一个非常相似的问题,但它没有包含有关性能的具体陈述.