小编nai*_*rbv的帖子

我想做这样的事情:

sealed abstract class Base(val myparam:String)

case class Foo(override val myparam:String) extends Base(myparam)
case class Bar(override val myparam:String) extends Base(myparam)

def getIt( a:Base ) = a.copy(myparam="changed")

我不能,因为在getIt的上下文中,我没有告诉编译器每个Base都有一个'copy'方法,但copy也不是一个真正的方法所以我不认为有特征或抽象方法我可以放入Base以使其正常工作.或者,有吗？

如果我尝试将Base定义为abstract class Base{ def copy(myparam:String):Base },则case class Foo(myparam:String) extends Base结果为class Foo needs to be abstract, since method copy in class Base of type (myparam: String)Base is not defined

是否有其他方法告诉编译器所有Base类在其实现中都是case类？一些特征意味着"具有案例类的属性"？

我可以让Base成为一个案例类,但后来我得到编译器警告,说不推荐使用case类继承吗？

我知道我也可以:

def getIt(f:Base)={ 
  (f.getClass.getConstructors.head).newInstance("yeah").asInstanceOf[Base]
}

但是......这看起来很难看.

思考？我的整个方法是"错误的"吗？

更新我更改了基类以包含属性,并使案例类使用"override"关键字.这更好地反映了实际问题,并考虑到Edmondo1984的响应使问题更加真实.

我已经在haskell中读到了,在对迭代器进行排序时,它只根据需要计算qsort的大小,以返回在生成的迭代器上实际计算的值的数量(即,它是懒惰的,即,一旦它完成了LHS第一个数据透镜可以返回一个值,它可以在迭代器上调用"next"时提供一个值,而不是继续旋转,除非再次调用next.

例如,在haskell中,head(qsort list)是O(n).它只是在列表中找到最小值,并且不会对列表的其余部分进行排序,除非访问其余结果qsort list.

有没有办法在Scala中执行此操作？我想在集合上使用sortWith,但只能根据需要进行排序,这样我就可以使用mySeq.sortWith(<).take(3)并且不需要完成排序操作.

我想知道是否可以以懒惰的方式使用其他排序函数(如sortBy),以及如何确保懒惰,以及如何查找有关何时对Scala中的排序进行懒惰评估的任何其他文档.

更新/编辑:我正在寻找使用sortWith等标准排序函数的方法.我宁愿不必实现我自己的quicksort版本只是为了得到懒惰的评价.不应该将它构建到标准库中,至少对于支持懒惰的Stream这样的集合？

好的,我知道我应该对我的具体应用程序进行基准测试,等等等等等等,但是:

-Xmx的默认JVM设置,默认垃圾收集器等,是大多数典型Java程序的合理默认值的默认值,可能不适合惯用的Scala代码(部分原因是惯用的Scala会产生更多"垃圾") ").

所以我正在寻找可供选择的建议.典型的Scala程序是否需要更高的-Xmx设置？某些JVM是否比其他JVM更适合scala？对于Scala来说,一个不同的垃圾收集器(-XX:+ UseParallelGC vs XX:+ UseConcMarkSweepGC)通常比Java中通常默认的更安全/更好/更快的猜测/下注/默认值吗？对于Scala代码,我应该考虑哪些其他选项,以什么方式？

由于生成了更多临时对象,默认情况下,"年轻"代通常应该有更多空间吗？或者应该给年轻一代带来更少的空间来强制更频繁的垃圾收集？其他几代呢？

当然我仍然需要为我的特定应用程序调整这些东西,但一般我猜测对于典型的Scala程序,我的起点可能与Java中的不同.

我确实发现自己在某些特定应用程序中遇到了内存不足错误和"GC开销限制",或者只是让应用程序在垃圾收集暂停时花费了太多时间.在某种程度上,我可以通过调整选项解决这些问题,但我想了解其他经验,一般原则和起点.

List.max根据某些排序返回列表中的"最大"元素...但如果列表为空,则会得到一个java.lang.UnsupportedOperationException: empty.max.我真的不喜欢用if语句或匹配或其他任何东西乱抛垃圾代码.我想要最大的headOption之类的东西,但我没有看到这样的方法.获得list.maxOption等效的最优雅方法是什么？

我无法理解/ reason之间的区别,例如,immutable.Map.transform和immutable.Map.map.看起来变换不会改变键,但这似乎是map方法的一个微不足道的变化.我错过了什么吗？

我希望找到一种方法,当/如果访问该元素时,将一个函数应用于地图的(键,值)(而不是必须使用map函数急切地迭代地图).这种方法存在吗？

我被告知(Scala)Actors实际上从不实际执行两个操作,这表明该行为(或反应？或接收？)方法本质上是同步的.我知道一个act方法中的长操作会导致阻塞问题,我认为必须以某种方式同步对消息队列的访问......但是......

建议的是,接收消息告诉它增加内部计数器的actor将以线程安全的方式递增计数器.不会同时处理两条更新消息,因此没有两条消息可以同时尝试更新计数器.

演员中的计数器属性听起来像"共享状态".

这样的操作是完全线程安全的吗？如果是这样,演员如何以一种有效的方式使用多个核心机器？演员如何多线程？

如果没有,那么以线程安全方式计算消息而不需要某些synchronized/volatile变量的适当惯用方法是什么？

看起来不一致的是,在Scala中,整数运算div除零抛出a java.lang.ArithmeticException: / by zero,但浮点运算(1.0/0.0)返回Double.Infinity.

我理解从类型的角度来看,同时拥有Double.Infinity和Integer.Infinity可能很棘手,但我认为使用scala强大的类型系统他们可以想出一些其他方法来解决问题的这个方面.

还有其他我想念的东西可以更好地解释这两种不同的行为吗？

所以，这是一个人为的例子：

trait MyTrait { 
  type T <: MyTrait
  val listOfT:List[T]
  def getFirst:T
  //def getOne:T = if( listOfT.length > 0 ) { getFirst } else { this }
}

class MyClass extends MyTrait {
  type T = MyClass
  override val listOfT:List[T] = List[MyClass](this)
  override def getFirst:T = listOfT.head
}

这个问题有两个部分：

是否有其他方法可以做到这一点，其中 MyClass 中的返回类型可以只是“MyClass”，而不必指定“type T = MyClass”？基本上，我希望能够将此特征添加到一个类中，而不必真正让子类显着改变其实现或考虑类型系统......只返回其自身的成员，并让该特征接受任何内容，只要它在子类型上是协变的。这还有道理吗？

在 MyTrait 中，如果取消注释，getOne 方法将给出错误“类型不匹配：”found : MyTrait.this.type (withunderlying type MyTrait) required: MyTrait.this.T

如果我将返回类型更改为 this.type，我会得到相反的找到/必需类型不匹配。两个返回值实际上具有相同的类型（并且实际上是相同的对象）。

处理此类情况的正确方法是什么？

我最近在Java虚拟机规范中读到JVM不支持NaN值,也不支持信号溢出的方法.

我特别指的是jvms 7的第2.8.1节,JVM支持的浮点运算和IEEE 754之间的主要区别,这一点指出:

"The floating-point operations of the Java Virtual Machine do not throw
exceptions, trap, or otherwise signal the IEEE 754 exceptional conditions of
invalid operation, division by zero, overflow, underflow, or inexact. The Java
Virtual Machine has no signaling NaN value."

我错过了解这个吗？在Scala(它依赖于字节码中的Java原语来表示数字类型),以及Java的Double对象中,有一个NaN和一个正/负无穷大值(在Java中记录了相应的二进制值).如果JVM不支持它们,如何有效地处理这些问题？

我在看:https: //github.com/typesafehub/config

假设我想要一个默认配置,例如reference.conf,然后我想要dev/prod覆盖(两个不同的application.conf),然后我还想要从这两个应用程序继承的特定于主机的覆盖.conf并最终默认为reference.conf.我该怎么做？

例如,我想象的目录结构如下:

resources/reference.conf
resources/prod/application.conf
resources/prod/master.conf
resources/prod/slave.conf
resources/dev/application.conf
resources/dev/master.conf
resources/dev/slave.conf

或者它可能是资源/ dev/master/application.conf？

某处我会指定一个环境,即可能从应用程序启动的主机名中提取.

如果应用程序是master.dev.example.com,我希望我能够做类似的事情:

getConfigurations("dev/master.conf").withDefaultsFrom(
    getConfigurations("dev/application.conf").withDefaultsFrom(
        getConfigurations("resource.conf"))

但是我很难理解使用给定库的确切结果.

我看到我可以设置一个config.resource系统属性,但看起来它只允许一级覆盖,dev-application.conf - > resources.conf,而不是像master-node.conf那样 - > dev-application .conf - > resources.conf.

我看到一个.withFallback方法,但似乎我想在一个文件中混合两种配置,而不是将资源/文件链接在一起.

我发现自己经常想放下一个List的头,如果它在那里.我知道我可以:

myList match {
  case h :: t => t
  case x => Nil
}

但是在我的代码中,这变得非常冗长,因为我需要做很多事情.

什么更简单/更短/更简洁？我有点想要像headOption这样的东西,但是对于尾巴....不会在空列表中抛出匹配错误.

想法？

我可以:

scala> def foo( f: => String) = println(f)
foo: (f: => String)Unit

我可以:

scala> def foo( f: String*) = f.map(println)
foo: (f: String*)Seq[Unit]

但我不能:

scala> def foo( f: =>String* ) = f.map(println)
<console>:1: error: ')' expected but identifier found.
       def foo( f: =>String* ) = f.map(println)
                       ^

也不

scala> def foo( f: (=>String)* ) = f.map(println)
<console>:1: error: no by-name parameter type allowed here
       def foo( f: (=>String)* ) = f.map(println)
                ^

还有其他方法可以做我想要的吗？为什么不允许这样做？

在twitter发布的文档" Effective Scala "中,我看到了一个代码示例:

class Pool(conns: Seq[Conn]) {
  private[this] val waiters = new Broker[Conn]
  private[this] val returnConn = new Broker[Conn]

  val get: Offer[Conn] = waiters.recv
  def put(c: Conn) { returnConn ! c }

  private[this] def loop(connq: Queue[Conn]) {
    Offer.choose(
      if (connq.isEmpty) Offer.never else {
        val (head, rest) = connq.dequeue
        waiters.send(head) { _ => loop(rest) }
      },
      returnConn.recv { c => loop(connq enqueue c) }
    ).sync()
  }

  loop(Queue.empty ++ conns)
}

代码似乎不是尾递归的,并且没有注释.由于这是一个连接池,可能会在程序的生命周期中保持运行,这会阻止像这样的池最终炸毁堆栈,并生成StackOverflowException？