标签: scala-2.11

在scala(2.10.3)REPL的最后一个版本中,我可以键入exit以退出REPL.但是,在Scala 2.11.0中,这不起作用.

$ scala
Welcome to Scala version 2.11.0 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_51).
Type in expressions to have them evaluated.
Type :help for more information.

scala> exit
<console>:8: error: not found: value exit
              exit
              ^

scala>

我正在调用API,但大多数情况下我一直收到错误:" 自SSL连接已关闭后删除关闭 "和" 过早连接关闭(服务器似乎不支持请求流水线)". "就像90%的时间我得到了这个错误,这意味着:在非常罕见的情况下,查询会返回它应该的数据.

为了确保这不是API的服务器问题,我使用Node.js(Express和Request libs)复制相同的查询,并且它每次都有效.这让我几乎可以肯定是一个喷雾虫.

这是代码的示例:

case class MyClass(user: String, pass: String)

class MyActor extends Actor {
  import spray.client.pipelining._
  import spray.http.BasicHttpCredentials
  import spray.http.{HttpRequest,HttpResponse}
  import scala.concurrent.Future

  import context.dispatcher

  def receive = {
    case myClass: MyClass => {
      val credentials: BasicHttpCredentials = BasicHttpCredentials(myClass.user, myClass.pass)
      val url: String = "https://myApi?params=values"
      val request: HttpRequest = Get(url) ~> addCredentials(credentials)
      val pipeline = sendReceive
      val response: Future[HttpResponse] = pipeline(request)
      val finalRes: Future[String] = response.map{ r =>
        println(r)
        r.entity.asString
      }
      finalRes pipeTo …

那可以做些什么呢？

我已经运行了一些测试,似乎Scala Hashmap比Java HashMap慢得多.请证明我错了!

对我来说,Hashmap的重点是快速访问给定键的值.因此,当速度很重要时,我发现自己会使用Java HashMap,这有点让人伤心.我没有足够的经验肯定地说,但似乎你混合Java和Scala越多,你可能面临的问题就越多.

test("that scala hashmap is slower than java") {
    val javaMap = new util.HashMap[Int,Int](){
      for (i <- 1 to 20)
      put(i,i+1)
    }

    import collection.JavaConverters._
    val scalaMap = javaMap.asScala.toMap

    // check is a scala hashmap
    assert(scalaMap.getClass.getSuperclass === classOf[scala.collection.immutable.HashMap[Int,Int]])

    def slow = {
      val start = System.nanoTime()
      for (i <- 1 to 1000) {
        for (i <- 1 to 20) {
          scalaMap(i)
        }
      }
      System.nanoTime() - start
    }

    def fast = {
      val start = System.nanoTime()
      for …

我正在使用Scala 2.11.1和sbt 0.13.5.

我有一个sbt插件,其中包含一个帮助函数来创建输入任务,如下所示(实现被删除,因为它与问题无关):

def register(name: String, description: String): Def.Setting[InputTask[Unit]] = {
    InputKey[Unit](name, description) <<= Def.inputTask { 
        println("test")
    }
}

此函数在Scala 2.10.4中编译并正常工作,但是一旦切换到2.11.1,它就会失败并出现以下错误:

无法扩展由以前版本的Scala编译的宏

在Def.inputTask宏观只是打破了斯卡拉2.11.1,还是我失去了一些明显的细节？

现在,上面的函数驻留在可以想象的最简单的sbt插件中.完全没有依赖关系.

我是Scala(使用2.10)和Slick(使用2.0-M2)的新手.我看到在Slick中绕过表的22列限制的方法之一是使用嵌套元组.尽管在GitHub上找到了这个部分代码,但我无法弄清楚如何做到这一点.

当前的dev分支Scala(2.11-M5)支持具有22个以上元素的case类,但不支持arity> 22的元组.而Slick尚未针对Scala 2.11预发行版进行分发.如何定义33列表(并使其与所有Slick的语法糖一起使用)？

NB,我正在尝试支持现有架构,无法更改表规范化.

我正在尝试将我的项目编译为Scala 2.10和2.11,以便我可以为两个scala版本发布版本,但每次尝试执行此操作时都会失败,并显示以下消息:

#( 04/26/14@ 7:40 )( mauricio@Mauricios-MacBook-Pro ):~/projects/scala/postgresql-netty@scala-2.11?
   sbt compile
[info] Loading project definition from /Users/mauricio/projects/scala/postgresql-netty/project
[info] Set current project to db-async-base (in build file:/Users/mauricio/projects/scala/postgresql-netty/)
[info] Compiling 61 Scala sources and 1 Java source to /Users/mauricio/projects/scala/postgresql-netty/db-async-common/target/scala-2.11/classes...
[error] error while loading Object, Missing dependency 'object scala in compiler mirror', required by /Library/Java/JavaVirtualMachines/jdk1.7.0_45.jdk/Contents/Home/jre/lib/rt.jar(java/lang/Object.class)
scala.reflect.internal.MissingRequirementError: object scala in compiler mirror not found.
    at scala.reflect.internal.MissingRequirementError$.signal(MissingRequirementError.scala:17)
    at scala.reflect.internal.MissingRequirementError$.notFound(MissingRequirementError.scala:18)
    at scala.reflect.internal.Mirrors$RootsBase.getModuleOrClass(Mirrors.scala:53)
    at scala.reflect.internal.Mirrors$RootsBase.getModuleOrClass(Mirrors.scala:66)
    at scala.reflect.internal.Mirrors$RootsBase.getPackage(Mirrors.scala:173)
    at scala.reflect.internal.Definitions$DefinitionsClass.ScalaPackage$lzycompute(Definitions.scala:161)
    at scala.reflect.internal.Definitions$DefinitionsClass.ScalaPackage(Definitions.scala:161)
    at scala.reflect.internal.Definitions$DefinitionsClass.ScalaPackageClass$lzycompute(Definitions.scala:162)
    at scala.reflect.internal.Definitions$DefinitionsClass.ScalaPackageClass(Definitions.scala:162)
    at scala.reflect.internal.Definitions$DefinitionsClass.init(Definitions.scala:1375)
    at …

从源代码scala/Equals.scala(这里):

package scala
trait Equals extends scala.Any {
  def canEqual(that: scala.Any): scala.Boolean
  def equals(that: scala.Any): scala.Boolean
}

在文档中,它说:

应该从每个设计良好的equals方法调用的方法,该方法在子类中被重写.

我随机挑选了一个扩展的类,这个类scala.Equals很容易理解.我选择了scala.Tuple2[+T1, +T2],这扩展了特性scala.Product[T1, T2],这反过来扩展了特征scala.Product,从而扩展了特征scala.Equals.

不幸的是,似乎因为scala.Tuple2是一个案例类,所以canEqual()和equals()方法是自动生成的,因此无法在源代码中找到scala/Tuple2.scala(这里).

我的问题是:

• 什么时候延长特质scala.Equals？
• 应该如何canEqual()实施？
• 使用的最佳实践(或样板)canEqual()是equals()什么？

提前致谢!

PS:万一重要,我使用的是Scala 2.11.7.

我有以下代码在Scala 2.10中工作,以在Scala中运行时编译外部类

/**
  * Compile scala files and keep them loaded in memory
  * @param classDir Directory storing the generated scala files
  * @throws IOException if there is problem reading the source files
  * @return Classloader that contains the compiled external classes
  */
@throws[IOException]
def compileFiles(classDir: String): AbstractFileClassLoader = {
  val files = recursiveListFiles(new File(classDir))
                  .filter(_.getName.endsWith("scala"))
  println("Loaded files: \n" + files.mkString("[", ",\n", "]"))

  val settings: GenericRunnerSettings = new GenericRunnerSettings(err => println("Interpretor error: " + err))
  settings.usejavacp.value = true
  val interpreter: …

我刚刚将Scala项目从2.10更新到2.11.2.

对于以下代码:

 if( x < 1.e-150 ) // conditional ops... 

我收到了错误

e不是Int的成员

以前的科学概念已经奏效了.我怀疑这不是2.11的事情,但更可能是升级的一些奇怪,这在很大程度上只是更新sbt文件的情况:

scalaVersion := "2.11.2"

之前的地方:

scalaVersion := "2.10.3"

我想不出可能导致这种情况的原因.我所知道的是它在2.10下工作正常.

有没有人见过这个问题或者可以建议修复？(或新的询问线!)

我正在使用JDK 1.7.0_21和sbt.version=0.13.5.

任何帮助或想法赞赏.

我们的应用程序基于Play 2.4与Scala 2.11和Akka构建.使用的数据库是MySQL.

缓存在我们的应用程序中大量使用.我们使用Play的默认EhCache进行缓存.

我们的示例代码段:

import play.api.Play.current
import play.api.cache.Cache

case class Sample(var id: Option[String],
                 //.. other fields
)

class SampleTable(tag: Tag)
  extends Table[Sample](tag, "SAMPLE") {
  def id = column[Option[String]]("id", O.PrimaryKey)
  // .. other field defs
}

object SampleDAO extends TableQuery(new SampleTable(_)) with SQLWrapper {
  def get(id: String) : Future[Sample] = {
    val cacheKey = // our code to generate a unique cache key
    Cache.getOrElse[Future[[Sample]](cacheKey) {
      db.run(this.filter(_.id === id).result.headOption)
    }
  }
}

我们使用Play的内置Specs2进行测试. …