标签: scala

如何将其转换为Int而不是 Some(Int)

val a: Option[Any] = Some(1)

我试过toInt,它给了一个错误value toInt is not a member of Option[Any]

我正试图从并行集合转换回常规地图.根据api,如果我在任何适当定义的并行集合上调用map,它应该返回一个标准的Map,但是它会在一个扁平的iterables集合上返回ParMap.

我有一个

val task: Stream[Future[Iterable[Tuple2[String, String]]]]

从中得到:

val res: ParSeq[Iterable[Tuple2[String, String]]] = tasks.par.map(f => f.apply())

最后:

val finalresult = res.flatten.toMap

不幸的是,类型finalresult是ParMap[String, String].

另一方面,如果我称之为:

tasks.par.map(f => f.apply()).reduce(_++_).toMap

那么返回类型是Map[String, String].

谁能告诉我为什么会这样？和(出于好奇),我怎么可以强制转换ParMap到Map时斯卡拉不会放过我？

我想做这样的事情:

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的响应使问题更加真实.

我会给你tl; dr在前面

我想使用的状态单子转换Scalaz 7通过一个分析器,线程额外的状态,我无法做任何有用的事情而无需编写大量的t m a -> t m b版本m a -> m b的方法.

解析问题的示例

假设我有一个包含嵌套括号的字符串,其中包含数字:

val input = "((617)((0)(32)))"

我还有一个新的变量名称流(在这种情况下是字符):

val names = Stream('a' to 'z': _*)

我想从流的顶部拉出一个名称,并在解析它时将其分配给每个括号表达式,然后将该名称映射到表示括号内容的字符串,并将嵌套的括号表达式(如果有)替换为他们的名字.

为了使这更具体,这就是我希望输出看起来像上面的示例输入:

val target = Map(
  'a' -> "617",
  'b' -> "0",
  'c' -> "32",
  'd' -> "bc",
  'e' -> "ad"
)

在给定级别可能存在一串数字或任意多个子表达式,但这两种内容不会在单个括号表达式中混合.

为了简单起见,我们假设名称流永远不会包含重复项或数字,并且它总是包含足够的输入名称.

使用具有一些可变状态的解析器组合器

上面的示例是此Stack Overflow问题中解析问题的略微简化版本 .我用一个大致如下的解决方案回答了这个问题:

import scala.util.parsing.combinator._

class ParenParser(names: Iterator[Char]) extends RegexParsers {
  def paren: Parser[List[(Char, String)]] …

我已经潜入函数式编程超过3年了,我一直在阅读和理解函数式编程的许多文章和方面.

但我经常偶然发现许多关于副作用计算中"世界"的文章,以及在IO monad样本中携带和复制"世界"的文章.在这种情况下,"世界"意味着什么？这在所有副作用计算环境中是否与"世界"相同,还是仅在IO monads中应用？

关于Haskell的文档和其他文章也多次提到"世界".

关于这个"世界"的一些参考:http: //channel9.msdn.com/Shows/Going+Deep/Erik-Meijer-Functional-Programming

这个:http: //www.infoq.com/presentations/Taming-Effect-Simon-Peyton-Jones

我期待一个样本,而不仅仅是对世界概念的解释.我欢迎Haskell,F#,Scala,Scheme中的示例代码.

我正在尝试使用sbt-assembly将scala项目转换为可部署的胖jar .当我在sbt中运行我的程序集任务时,我收到以下错误:

Merging 'org/apache/commons/logging/impl/SimpleLog.class' with strategy 'deduplicate'
    :assembly: deduplicate: different file contents found in the following:
    [error] /Users/home/.ivy2/cache/commons-logging/commons-logging/jars/commons-logging-1.1.1.jar:org/apache/commons/logging/impl/SimpleLog.class
    [error] /Users/home/.ivy2/cache/org.slf4j/jcl-over-slf4j/jars/jcl-over-slf4j-1.6.4.jar:org/apache/commons/logging/impl/SimpleLog.class

现在来自sbt-assembly文档:

如果多个文件共享相同的相对路径(例如,多个依赖项JAR中名为application.conf的资源),则默认策略是验证所有候选项具有相同的内容,否则出错.可以使用以下内置策略之一或编写自定义策略在每个路径的基础上配置此行为:

• MergeStrategy.deduplicate 是上面描述的默认值
• MergeStrategy.first 选择classpath顺序中的第一个匹配文件
• MergeStrategy.last 挑选最后一个
• MergeStrategy.singleOrError 在冲突时出现错误消息
• MergeStrategy.concat 简单地连接所有匹配的文件并包含结果
• MergeStrategy.filterDistinctLines 也可以连接,但在此过程中会留下重复的内容
• MergeStrategy.rename 重命名源自jar文件的文件
• MergeStrategy.discard 只是丢弃匹配的文件

通过这个我设置我的build.sbt如下:

import sbt._
import Keys._
import sbtassembly.Plugin._
import AssemblyKeys._
name := "my-project"
version := "0.1"
scalaVersion := "2.9.2"
crossScalaVersions := Seq("2.9.1","2.9.2")

//assemblySettings
seq(assemblySettings: _*)

resolvers ++= Seq(
    "Typesafe Releases Repository" at "http://repo.typesafe.com/typesafe/releases/",
    "Typesafe Snapshots Repository" at "http://repo.typesafe.com/typesafe/snapshots/",
    "Sonatype Repository" at …

我们假设我们有一个泛型类Container:

case class Container[+A](value: A)

然后,我们希望模式匹配一个Container有Double和Container的Any:

val double = Container(3.3)  
var container: Container[Any] = double

为此,我们通常会写:

container match {  
  case c: Container[String] => println(c.value.toUpperCase)
  case c: Container[Double] => println(math.sqrt(c.value))  
  case _ => println("_")  
}

但是,编译器会给出两个警告,前两个案例各一个.例如,第一个警告说:"类型模式容器[String]中的非变量类型参数字符串未被选中,因为它被擦除".由于擦除,在运行期间不可能区分不同类型的容器并且第一个捕获物将匹配.因此,类型的容器Container[Double]将与捕获Container[String]对象的第一个案例匹配,因此toUpperCase将在a上调用方法,Double并且java.lang.ClassCastException将抛出a.

如何匹配Container特定类型的参数化？

我目前正在下班后的空闲时间参加Coursera的Scala课程,试图最终尝试函数式编程.我目前正在进行一项任务,我们应该"计算"包含一些对象的两个集合的并集.我故意省略细节,因为这对我在这里要问的内容并不重要.然而,相关的是集合被定义为二叉树,每个节点包含一个元素和两个子树.

既然如此; union讲座中的例子如下:

def union(other:BTSet) :BTSet = ((left union right) union other) incl element

问题1:坦率地说,即使在阅读了相关的FAQ和其他论坛帖子之后,我仍然不明白这个功能的工作原理和原因.除了incl在头节点添加(调用)元素之外,在union实现中绝对没有完成"动作" ,它只是一遍又一遍地调用自身.我会非常感谢一些解释......

问题2:课程论坛包含许多帖子,说明这个解决方案根本没有效率,而且还不够好.看到我不明白它是如何工作的我开始并不真正理解为什么它不够好.

请注意,我不以任何方式要求为分配解决方案提供扰流板.我更愿意"为年级做好工作",但我根本不明白我应该在这里做些什么.我不相信课程中提供的说明和指导足以让您了解函数式编程的怪癖,因此我欢迎任何有关如何正确思考而不是如何正确编码的评论/答案.

有人可以提供使用当前scala表示编译器(即)的最小示例scala.tools.nsc.interactive.Global,它可以完成以下任务吗？

• 编译单个虚拟源文件(即不在文件系统中,但例如a String)
• 从编译器检索所有阶段的结果信息
• 将源文件中的更改传播到编译器
• 可能异步接收进一步的信息

似乎有很多波动nsc,我找不到最新的小例子.所以我非常感谢你的帮助.

初学者斯卡拉问题,但我在这里找不到答案.

与C++中的重载类似,我希望编译器可以区分一个名为-一个参数的方法(与类相同的类型)和一个-不带参数的一元版本,为什么unary_需要呢？