小编Pen*_*gin的帖子

作为练习,我想将Scala数组集合扩展到我自己的OneBasedArray(做你期望的,索引从1开始).由于这是一个不可变的集合,我想让它在调用filter/map等时返回正确的类型.

我已经在这里,这里和这里阅读了资源,但我很难理解如何将其转换为数组(或者除了示例中的集合之外的其他集合).我是否在这种结构的正确轨道上？

class OneBasedArray[T] 
  extends Array[T] 
  with GenericTraversableTemplate[T, OneBasedArray]
  with ArrayLike[T, OneBasedArray]

是否还有其他资源可以帮助解释扩展集合？

感谢这篇文章,我正在了解依赖方法类型.我有一个类似于以下的结构

trait Environment{
    type Population <: PopulationBase
    protected trait PopulationBase

    def evolveUs(population: Population): Population
}

object FactoredOut{
    def evolvePopulation(env: Environment)(prevPopulation: env.Population): env.Population = {
        env.evolveUs(prevPopulation)
    }
}

我现在想开始使用actor在FactoredOut整个集群中传播工作.要做到这一点,我需要一种方法来传递带有的不可变消息Environment.

显然以下不起作用,但演示了我正在尝试做的事情

object Messages{
    case class EvolvePopulation(env: Environment)(prevPopulation: env.Population)
}

通过人口的正确方法是什么？周围的环境是什么？

(会添加dependent-method-types标记,但是我没有足够的点来添加'new'标记)

我正在努力研究是否应该在工作中尝试Condor或Sun Grid Engine(或者可能是其他东西).

我们经常有很多未使用的WinXp工作站.希望我们可以使用局域网唤醒,运行所有工作,然后自动关闭.我们主要运行Matlab,Java或Python模拟monte-carlo或参数探索.

由于我对Condor的了解有限,听起来使用vm Universe可能是一种处理快照的便捷方式,而无需修改现有代码.

对于这种工作,SGE还是其他比秃鹰更好的东西？

我现在很好地学习Scala并非常享受它; 我希望在其中开始未来的项目,而不是Java.我更少享受的是(相对)糟糕的IDE支持.我发现IDEA和Eclipse都带有Scala插件(包括夜间版本)有点不可靠或难以使用 - 我想要一些我总能依赖的东西.例如,昨天我无法全新安装eclipse +插件来运行我的测试,甚至打开一个编辑器窗口!

我正在考虑在Eclipse/IDEA之间跳跃,这取决于最适合手头的任务,更重要的是减少我对构建和运行测试的IDE的依赖(ScalaTest).这对我来说非常重要,因为我在Eclipse中长大了Java; 让Eclipse SVN使用GIT最初是一件大事.鉴于我只有时间学习一个工具,它应该是Ant,Maven,buildr,sbt,.... 其他人如何工作？

如果我写

class Things扩展scala.collection.immutable.HashSet [Int]

新事物+5

然后结果是

res0:scala.collection.immutable.HashSet [Int] = Set(5)

我需要做什么做的结果是类型的东西？我怀疑答案可能在这里,但我正在努力了解正在发生的事情.

我正在努力减少像Java一样编写Scala(2.8)的程度.这是我遇到的问题的简化.您能否建议改进我的"功能更强大"的解决方案？

变换地图

val inputMap = mutable.LinkedHashMap(1->'a',2->'a',3->'b',4->'z',5->'c')

通过丢弃值为'z'的任何条目并在遇到它们时索引字符

第一次尝试

var outputMap = new mutable.HashMap[Char,Int]()
var counter = 0
for(kvp <- inputMap){
  val character = kvp._2
  if(character !='z' && !outputMap.contains(character)){
    outputMap += (character -> counter)
    counter += 1
  }
}

第二次尝试(不是更好,但使用不可变的地图和'foreach')

var outputMap = new immutable.HashMap[Char,Int]()
var counter = 0
inputMap.foreach{
  case(number,character) => {
    if(character !='z' && !outputMap.contains(character)){
      outputMap2 += (character -> counter)
      counter += 1
    }
  }
}

我正在学习Squeryl并尝试理解'using'语法,但无法找到它的文档.

在以下示例中,创建了两个数据库,A包含单词Hello,B包含Goodbye.目的是查询A的内容,然后附加单词World并将结果写入B.

预期的控制台输出是Inserted Message(2,HelloWorld)

object Test {
    def main(args: Array[String]) {
        Class.forName("org.h2.Driver");
        import Library._

        val sessionA = Session.create(DriverManager.getConnection(
                "jdbc:h2:file:data/dbA","sa","password"),new H2Adapter)
        val sessionB = Session.create(DriverManager.getConnection(
                "jdbc:h2:file:data/dbB","sa","password"),new H2Adapter)

        using(sessionA){
            drop; create
            myTable.insert(Message(0,"Hello"))
        }
        using(sessionB){
            drop; create
            myTable.insert(Message(0,"Goodbye"))
        }

        using(sessionA){
            val results = from(myTable)(s => select(s))//.toList

            using(sessionB){
                results.foreach(m => {
                    val newMsg = m.copy(msg = (m.msg+"World"))
                    myTable.insert(newMsg)
                    println("Inserted "+newMsg)
                })
            }
        }
    }

    case class Message(val id: Long, val msg: String) extends KeyedEntity[Long]
    object Library extends …

在Scala(2.10)中,如果我要求a,List(1.0, 2)那么我会得到一个List[Double],如预期的那样.

但...

如果我要求Map(1.0 -> 'A', 2 -> 'B')我得到一个Map[AnyVal, Char].我希望钥匙是类型的Double.要求Map[Double, Char](1.0 -> 'A', 2 -> 'B)在'2'上给出类型不匹配.

这让我觉得最让人困惑!它不一致吗？

旁白: List[(Double, Char)]((1.0, 'A'), (2, 'B')).toMap虽然给了我一张地图[Double,Char].

为什么下面的代码中出现空指针异常？

object Test extends App{
    trait MyTrait[A]{ self =>
        val seq: Seq[A]
        val size = seq.size // null pointer here
    }

    val p = new MyTrait[Int]{
        val seq = Seq(1,2,3)
    }
}

如果我将size字段更改为lazy,那就没关系.

学习 Akka 流。我有一个记录流，每个时间单位有很多记录，已经按时间排序（来自 Slick），并且我想将它们分批放入时间组中，以便通过检测时间步长何时发生变化来进行处理。

例子

case class Record(time: Int, payload: String)

如果传入的流是

Record(1, "a")
Record(1, "k")
Record(1, "k")
Record(1, "a")
Record(2, "r")
Record(2, "o")
Record(2, "c")
Record(2, "k")
Record(2, "s")
Record(3, "!")
...

我想把它变成

Batch(1, Seq("a","k","k","a"))
Batch(2, Seq("r","o","c","k","s"))
Batch(3, Seq("!"))
...

到目前为止，我只发现按固定数量的记录进行分组，或者分成许多子流，但从我的角度来看，我不需要多个子流。

更新：我发现batch，但它看起来更关心背压，而不仅仅是一直批处理。