在Scala中,我们可以使用至少两种方法来改进现有或新类型.假设我们想要表达某些东西可以使用a来量化Int.我们可以定义以下特征.

隐式转换

trait Quantifiable{ def quantify: Int }

然后我们可以使用隐式转换来量化例如字符串和列表.

implicit def string2quant(s: String) = new Quantifiable{ 
  def quantify = s.size 
}
implicit def list2quantifiable[A](l: List[A]) = new Quantifiable{ 
  val quantify = l.size 
}

导入这些后,我们可以quantify在字符串和列表上调用该方法.请注意,可量化列表存储其长度,因此它可以避免在后续调用时对列表进行昂贵的遍历quantify.

输入类

另一种方法是定义一个"证据" Quantified[A],表明某种类型A可以量化.

trait Quantified[A] { def quantify(a: A): Int }

然后,我们提供这种类型的类的实例为String和List地方.

implicit val stringQuantifiable = new Quantified[String] {
  def quantify(s: String) = s.size 
}

如果我们编写一个需要量化其参数的方法,我们写道:

def sumQuantities[A](as: List[A])(implicit ev: Quantified[A]) = 
  as.map(ev.quantify).sum …

我正在使用Java处理一些Java源代码.我正在提取字符串文字并将它们提供给一个带字符串的函数.问题是我需要将未转义的String版本传递给函数(即这意味着转换\n为换行符,转换为\\单行\等).

Java API中是否有一个函数可以执行此操作？如果没有,我可以从某个库获得这样的功能吗？显然,Java编译器必须进行此转换.

如果有人想知道,我试图在反编译的混淆Java文件中取消混淆字符串文字.

鉴于eithers的序列Seq[Either[String,A]]与Left作为一个错误消息.我想获得一个Either[String,Seq[A]]在那里我得到了Right(这将是一个Seq[A]),如果序列的所有元素Right.如果至少有一个Left(错误消息),我想获取第一条错误消息或所有错误消息的串联.

当然你可以发布scalaz代码,但我也对不使用它的代码感兴趣.

编辑

我改变了标题,最初要求Either[Seq[A],Seq[B]]反映信息的正文.

有一些关于在ggplot中绘制累积密度的帖子.我目前正在使用Easier方式接受的答案来绘制ggplot中的累积频率分布？用于绘制我的累积计数.但是这种解决方案涉及预先预先计算这些值.

在这里,我正在寻找一个纯粹的ggplot解决方案.让我们展示一下到目前为止:

x <- data.frame(A=replicate(200,sample(c("a","b","c"),1)),X=rnorm(200))

ggplot的 stat_ecdf

我可以使用ggplot stat_ecdf,但它只绘制累积密度:

ggplot(x,aes(x=X,color=A)) + geom_step(aes(y=..y..),stat="ecdf")

我想做类似以下的事情,但它不起作用:

ggplot(x,aes(x=X,color=A)) + geom_step(aes(y=..y.. * ..count..),stat="ecdf")

cumsum 和 stat_bin

我发现了一个使用cumsum和的想法stat_bin:

ggplot(x,aes(x=X,color=A)) + stat_bin(aes(y=cumsum(..count..)),geom="step")

但正如您所看到的,下一种颜色不是从y=0最后一种颜色开始,而是最后一种颜色结束的颜色.

我要求的是什么

从最好到最差我想拥有什么:

1. 理想情况下,一个简单的解决方案是不工作

   ggplot(x,aes(x=X,color=A)) + geom_step(aes(y=..y.. * ..count..),stat="ecdf")
   

   Run Code Online (Sandbox Code Playgroud)

2. 一种更复杂的stat_ecdf计数方法.

3. 最后的办法是使用这种cumsum方法,因为它会产生更糟糕的(分类)结果.

我的build.sbt文件中有以下几行.

resolvers += "specs2 snapshot repo" at "http://scala-tools.org/repo-snapshots"

libraryDependencies += "org.specs2" %% "specs2" % "1.7-SNAPSHOT" % "test"

现在,如果快照已经改变(这是否合理,maven SNAPSHOT版本在没有版本号改变的情况下发生变化？),我该如何告诉sbt下载新版本？使用update什么都不做.

我正在写一个包含一些功能性方法的类.首先,我使用List作为参数和返回类型编写它们.然后我想"嘿,你也可以使用更通用的类型!" 所以我用Seq取代了Lists,希望有一天我可以通过喂他们除了列表以外的东西来让我的东西变得更快.

那么我应该为哪些通用的堆栈式数据结构编写我的方法和算法？我能坚持一般的模式吗？所有这一切都是因为这些方法可能需要在将来进行优化,以防它们形成瓶颈.

更新

我会尝试更精确一点:假设您知道正在使用哪些操作,例如反转,.tail,直接元素访问或理解.我可以选择一个类型,这将迫使这些运营效率？

更新2

我非常了解各种任务的具体数据结构的性能.我不知道的是哪个数据结构可能显示为某种超类型的子类.

例如,我应该使用TraversableOnce或IndexedSeq而不是List或Array吗？它会给我买什么东西吗？

附加问题

什么是你的默认列表类似的数据结构的签名？你写的吗？

def a(b: List[A]): List[A] 

要么

def a(b: TraversableOnce[A]): TraversableOnce[A]

你能解释一下原因吗？

我遇到过在整个地图操作中多次维护状态的问题.想象一下以下任务:

给定List [Int],将每个元素映射到所有前面元素和它自身的总和.
因此1,2,3变为1,1 + 2,1 + 2 + 3.

我提出的一个解决方案是:

scala> val a = 1 to 5                                                
a: scala.collection.immutable.Range.Inclusive with scala.collection.immutable.Range.ByOne = Range(1, 2, 3, 4, 5)

scala> a.foldLeft(List(0)){ case (l,i) => (l.head + i) :: l }.reverse
res3: List[Int] = List(0, 1, 3, 6, 10, 15)

但不知何故,我觉得必须有一个更简单的解决方案.

我目前正在开发一个小型项目(<10k loc),它主要是纯粹的,但依赖于主要基于迭代器的可变优化和一些用于重载计算的数据结构重用.

我想学习更多功能编程,并希望通过例如将可变计算包装到状态变换器monad等中来获得更多类型安全性.为此目的,存在scalaz库.

问题一

当通过使用所有奇特的功能来大规模地抽象我的计算时,我会介绍我不会摆脱的性能杀手吗？就像我的计算被蒙纳德的膝盖深深地包裹起来一样？

问题二

考虑到Scala的有限类型推断,它是否可行？我目前正在与非常大的类型签名(可能因为我不知道如何正确摆脱它们).我认为更多"功能性"将引入更多这样的锅炉板代码.

放弃

我不是在质疑功能方法是好还是坏.向Haskell提出这个问题毫无意义.我在质疑Scala是否合情合理.

根据要求编辑:我的项目中的大型签名示例

(但这是一个不同的问题)

以下代码描述了对类型参数化输入对象(DiscreteFactorGraph[VariableType, FactorType[VariableType]])的迭代计算.你可以构造一个计算对象createInitialState并对其进行计算advanceState,最后从中提取一些信息marginals.

我希望在计算过程中保留因子图对象的类型(及其参数类型),以便最终的应用程序marginals产生正确的类型DiscreteMarginals[VariableType].我认为目前我只需要在计算类型(即TState)中保留变量类型,因此不使用携带因子类型.但是在不同的地方我甚DiscreteFactorGraph至需要变量的类型,所以我倾向于需要更多的类型信息在未来通过计算.

我很喜欢这部分,我希望有更好的解决方案.目前我有一个非常实用的方法,只有那三个功能.但我必须通过它们链接类型.或者,我可以将它定义为一个类,并使用所有这些类型对类进行参数化,因此我不必为每个方法重复类型参数.

object FloodingBeliefPropagationStepper extends SteppingGraphInferer {
  def marginals[V <: DiscreteVariable, F <: DiscreteFactor[V]](state: FloodingBeliefPropagationStepper.TState[V,F]): DiscreteMarginals[V] =
    BeliefPropagation.marginals(state._1, state._2)

  def advanceState[V <: DiscreteVariable, F <: DiscreteFactor[V]](state: FloodingBeliefPropagationStepper.TState[V,F]): FloodingBeliefPropagationStepper.TState[V,F] = {
    val graph = state._1
    (graph,
      BeliefPropagation.computeFactorMessages(
      graph,
      BeliefPropagation.computeVariableMessages(graph, state._2, graph.variables),
      graph.factors))
  }

  def createInitialState[V <: DiscreteVariable, F <: DiscreteFactor[V]](graph: DiscreteFactorGraph[V, F], …

我经常想做以下事情:

sapply(sapply(x, unique),sum)

我也可以这样写:

sapply(x, function(y) sum(unique(y)))

但我不喜欢每次写出lambda.那么有什么功能可以让我写吗？

sapply(x, concat(sum,unique))

并且concat只是连接这两个函数,从而创建一个新的函数,它们一个接一个地执行.

是否有可能,使用Scala的并行集合来并行化并且事先Iterator 没有完全评估它？

这里我谈论的是并行化函数转换Iterator,即map和flatMap.我认为这需要Iterator提前评估一些元素,然后计算更多,一旦消耗了一些元素next.

我所能找到的只需要将迭代器转换为a Iterable或者Stream最多.在Stream当我打电话,然后得到完全评估.par就可以了.

如果没有现成的建议,我也欢迎实施建议.实现应该支持并行map和flatMap.