小编huy*_*hjl的帖子

有一个关于Scala集合类的性能特征的方便页面.是否有关于内存占用的类似数据？

我有一种情况,我担心内存使用,并希望在我选择使用的集合中考虑这一点.例如,在Array[Array[T]]和之间Vector[Vector[T]].

我试图找出如何使用基于对我的Scalaz状态monad示例答案的评论StateT来组合两个State状态变换器.

看起来我很亲密,但在尝试申请时遇到了问题sequence.

import scalaz._
import Scalaz._
import java.util.Random

val die = state[Random, Int](r => (r, r.nextInt(6) + 1))

val twoDice = for (d1 <- die; d2 <- die) yield (d1, d2)

def freqSum(dice: (Int, Int)) = state[Map[Int,Int], Int]{ freq =>
  val s = dice._1 + dice._2
  val tuple = s -> (freq.getOrElse(s, 0) + 1)
  (freq + tuple, s)
}

type StateMap[x] = State[Map[Int,Int], x]

val diceAndFreqSum = stateT[StateMap, Random, Int]{ random …

在以下测试框架之间哪一个最容易使用和学习？

• scalacheck
• ScalaTest
• 眼镜

我正在使用2.8.0和sbt进行构建,因此很好地使用它是一个因素.我不一定会看到最全功能的.我最好能告诉我的标准是有序的:

• 允许对Scala代码进行单元测试
• 无痛的设置
• 与sbt合作
• 教程
• 丰富的文档

我发现在执行类型模式匹配时读取scala支持绑定类型变量的规范:

Map(1 -> "one", 2 -> "two") match {
  case l: Map[k, v] =>
    // binds k to Int and v to String
    // k and v are types as shown here:
    val i: Iterator[Tuple2[k, v]] = l.iterator
    println(i.mkString(", "))
}

我能做些什么花哨的东西或实用的东西吗？或绑定类型变量仅用于类型文档目的？

我想到Scala有时需要类型注释,比如定义函数,所以我试过:

def prepender(obj: Any) = obj match {
  case xs: List[a] => (x: a) => x :: xs
  case opt: Some[a] => (x: a) => x :: Nil
}

但是返回函数的类型很奇怪:

prepender: (obj: Any)a with a => List[Any] forSome …

似乎我可以使用self或this引用混合实例,或者更确切地说是限制混合实例.例如,那些是等价的吗？

scala> trait A { self: List[_] => }
defined trait A

scala> trait B { this: List[_] => }
defined trait B

这只是一个约定,还是使用不同的东西而不是this提供一些好处？

我在另一个答案中看到了Function.tupled示例的这种用法:Map(1 -> "one", 2 -> "two") map Function.tupled(_ -> _.length).

有用:

scala> Map(1 -> "one", 2 -> "two") map Function.tupled(_ -> _.length)
<console>:5: warning: method tupled in object Function is deprecated: 
Use `f.tuple` instead
       Map(1 -> "one", 2 -> "two") map Function.tupled(_ -> _.length)
                                                ^
res0: scala.collection.immutable.Map[Int,Int] = Map(1 -> 3, 2 -> 3)

如果我不想使用占位符语法,我似乎无法做到.

scala> Map(1 -> "one", 2 -> "two") map (x => x._1 -> x._2.length)
res1: scala.collection.immutable.Map[Int,Int] = Map(1 -> 3, 2 -> …

我有以下几套.我提前知道它会持续多长时间.

val sets = Set(Set("a","b","c"), Set("1","2"), Set("S","T"))

我想将它扩展为笛卡尔积:

Set("a&1&S", "a&1&T", "a&2&S", ..., "c&2&T")

你会怎么做？

前一阵子在Scala邮件列表上被询问并回答:

凯文:

给定一些嵌套结构:List[List[...List[T]]] 将它展平为最佳(最好是类型安全)的方法是什么List[T]

加斯帕:

隐含和默认参数的组合起作用:

case class Flat[T, U](fn : T => List[U]) 

implicit def recFlattenFn[T, U](implicit f : Flat[T, U] = Flat((l : T) 
=> List(l))) = 
   Flat((l : List[T]) => l.flatMap(f.fn)) 

def recFlatten[T, U](l : List[T])(implicit f : Flat[List[T], U]) = f.fn(l) 

例子:

scala> recFlatten(List(1, 2, 3)) 
res0: List[Int] = List(1, 2, 3) 

scala> recFlatten(List(List(1, 2, 3), List(4, 5))) 
res1: List[Int] = List(1, 2, 3, 4, 5) 

scala> recFlatten(List(List(List(1, 2, 3), List(4, 5)), …

以下博客文章展示了如何foldBack使用延续传递样式使F#尾部递归.

在Scala中,这意味着:

def foldBack[T,U](l: List[T], acc: U)(f: (T, U) => U): U = {
  l match {
    case x :: xs => f(x, foldBack(xs, acc)(f))
    case Nil => acc
  }
} 

通过这样做可以使尾递归:

def foldCont[T,U](list: List[T], acc: U)(f: (T, U) => U): U = {
  @annotation.tailrec
  def loop(l: List[T], k: (U) => U): U = {
    l match {
      case x :: xs => loop(xs, (racc => k(f(x, racc))))
      case Nil => k(acc)
    }
  }
  loop(list, u …

以下错误消息是什么意思？

如果没有被第二个成员覆盖的第三个成员,则不能覆盖具体成员(此规则旨在防止"意外覆盖");

我试图做可堆叠的特性修改.这是事后的一点点,因为我已经有了一个层次结构,我正在尝试修改行为,而不必重写大量的代码.

我有一个名为AbstractProcessor的基类,它定义了一个类似这样的抽象方法:

abstract class AbstractProcessor {
  def onPush(i:Info): Unit
}

我有几个现有的特征,以实现不同的onPush行为.

trait Pass1 {
  def onPush(i:Info): Unit = { /* stuff */ }
}

trait Pass2 {
  def onPush(i:Info): Unit = { /* stuff */ }
}

所以这允许我使用new AbstractProcessor with Pass1或new AbstractProcessor with Pass2.

现在我想在Pass1和Pass2中的onPush调用之前和之后进行一些处理,同时最小化对AbstractProcessor和Pass1和Pass2的代码更改.我想创建一个像这样的特性:

trait Custom extends AbstractProcessor {
  abstract override def onPush(i:Info): Unit = {
    // do stuff before
    super.onPush(i)
    // do stuff after
  }
}

并使用它,new AbstractProcessor with Pass1 with …