小编gia*_*olo的帖子

我想知道为什么scala.Option没有fold这样定义的方法:

fold(ifSome: A => B , ifNone: => B)

相当于

map(ifSome).getOrElse(ifNone)

有没有比使用map+ 更好的getOrElse？

使用Scala 2.7.7:

如果我有一个选项列表,我可以使用for-understandness来展平它们:

val listOfOptions = List(None, Some("hi"), None)
listOfOptions: List[Option[java.lang.String]] = List(None, Some(hi), None)

scala> for (opt <- listOfOptions; string <- opt) yield string
res0: List[java.lang.String] = List(hi)

我不喜欢这种风格,宁愿使用HOF.这种尝试过于冗长,无法接受:

scala> listOfOptions.flatMap(opt => if (opt.isDefined) Some(opt.get) else None)
res1: List[java.lang.String] = List(hi)

直觉上我会期望以下工作,但它没有:

scala> List.flatten(listOfOptions)
<console>:6: error: type mismatch;
 found   : List[Option[java.lang.String]]
 required: List[List[?]]
       List.flatten(listOfOptions)

即使以下似乎它应该工作,但不是:

scala> listOfOptions.flatMap(_: Option[String])
<console>:6: error: type mismatch;
 found   : Option[String]
 required: (Option[java.lang.String]) => Iterable[?]
       listOfOptions.flatMap(_: Option[String])
                          ^

我能想到的最好的是:

scala> listOfOptions.flatMap(_.toList)         
res2: List[java.lang.String] = List(hi) …

我是第一次教斯卡拉,我的学生们发现故意"惩罚"涉及伴侣物体非常混乱.请考虑以下示例:

class Stack {
  ... methods such as push/pop
}

object Stack {
  ... factory method(s) and possibly others
}

当我使用诸如"堆栈对象"或"堆栈对象"之类的语言短语或尤其是"堆栈对象"时,会出现混淆.我的学生很难理解我是指单身对象Stack还是Stack类的对象.

我正在寻找替代方法来表达这些初学者可以更容易理解的东西.我一直认为Stack类的对象总是称为"Stack实例"或"Stack的实例",但是当试图教OO不能称这些东西为对象时,它似乎很疯狂.在谈论单例对象Stack时,我一直试图总是使用短语"singleton object"或"companion object",但Scala的语法在那里对我不利,因为它只使用了"object"这个词.

在这种情况下,我可以重命名单例对象StackFactory而不是Stack,但这只是我自己的类的一个选项,而不是已经内置到Scala中的一千个和一个伴随对象.

编辑:

对不起,我的问题不够清楚.主要的混淆不是在引用伴侣对象时发生的.在这种情况下,正如几个人所指出的那样,很容易使用诸如"伴侣对象"之类的短语.相反,在引用普通实例时会发生主要的混淆.然后,如果我说"堆栈对象"(意思是一些堆栈实例)或"堆栈对象"(意味着这个特定实例),一些学生会认为我的意思是伴侣对象 - 即使我没有使用单词伴侣或单身人士.

我可以很好地看到混淆来自哪里,因为"对象"这个词只出现在程序文本中,只出现在伴侣对象中.

我的代码变得乱七八糟,使用以下代码模式:

val opt = somethingReturningAnOpt
if (opt.isDefinedAt) {
    val actualThingIWant = opt.get
}

有没有办法简化这个？(似乎不必要的复杂和代码味道).理想情况下它会是这样的:

if (Some(actualThingIWant) = somethingReturningAnOpt) {
   doSomethingWith(actualThingIWant)
}

有可能吗？

我有一个非常长的JSON来解析Gson,但为了简洁起见,我将它修剪为这个例子:

{
 "volumes": [
  {
   "status": "available", 
   "managed": true, 
   "name": "va_85621143-1133-412f-83b4-57a01a552638_", 
   "support": {
    "status": "supported"
   }, 
   "storage_pool": "pfm9253_pfm9254_new", 
   "id": "afb8e294-6188-4907-9f6f-963c7623cecb", 
   "size": 9
  }, 
  {
   "status": "in-use", 
   "managed": false, 
   "name": "bt_newd20", 
   "support": {
    "status": "not_supported", 
    "reasons": [
     "This volume is not a candidate for management because it is already attached to a virtual machine.  To manage this volume with PowerVC, select the virtual machine to which the volume is attached for management. The attached volume will be automatically included for management." …

假设我正在使用Scala项目中的Java库.Java库在所有地方都抛出了异常,但我觉得让它们"在Scala世界中"传播感觉不舒服,因为无法确定Scala方法可以抛出什么异常(除非记录它们).所以这是我倾向于编写的代码:

def doesNotThrowExceptions(parameter: String): Either[Throwable, T] =
  catching(classOf[IOException], classOf[NoSuchAlgorithmException]) either {
    // Code calling the Java library
    // Code generating a value of type T
  }

然后,通常,我将使用Either.RightProjection.flatMap链接返回Either[Throwable, ...]或Either.RightProjection.map混合返回Either[Throwable, ...]方法和其他方法的方法.或者只是Either.fold对Throwable价值做点什么.但不知怎的,这仍然感觉不完全正确.

这是处理Scala中Java异常的最"惯用"方式吗？有没有更好的方法？

只要我们有一个PartialFunction[X,R]很容易将它转换为返回的函数Option[R],例如

def pfToOptf[X, R](f: PartialFunction[X,R])(x: X) =
    if (f.isDefinedAt(x)) Some(f(x))
    else None

但是,如果任务相反,那该怎么办:假设我有一个函数作为参数f获取X并返回Option[R]结果.我想做出一个PartialFunction[X,R].什么是最好的方法？

我想出来的东西看起来很丑陋我的口味:

def optfToPf[X,R](f: X => Option[R]) : PartialFunction[X,R] = {
    object extractor {
        def unapply(x: X): Option[R] = f(x)
    }

    { case extractor(r) => r }
}

我错过了一些更好的方法吗？

是否可以指定一个快捷方式在New Java Class Dialog 上自动进行？在项目的最开始,当我创建很多类时,必须通过" 新建... "向导非常烦人.

这是我想要达到的对话框的图像.

我有一个返回Future的调用.但是,我需要拨打n个电话,这样我才会回来n期货.我想知道如何在继续之前获得所有解决方案(不阻止服务器)

例如,

while(counter < numCalls){
    val future = call(counter)
    future.map{  x =>
        //do stuff
    }
    counter += 1 
}

//Now I want to execute code here after ALL the futures are resolved without 
//blocking the server

最后,本文介绍了新的Java 8 Optional,并指出

可选项并不像Scala中的Option [T]那么强大(但至少它不允许包装null).API不像null处理那么简单,可能要慢得多.但编译时检查的好处加上可选性的可读性和文档值始终大大优于劣势

我对Scala有一个非常基本的了解,并且我熟悉Java 8 Optional,所以初看起来,我不清楚两者之间有什么区别,如果有的话.

我知道,例如,在Scala中我可以使用模式匹配来测试Option并让我的生活更轻松.但是,排除Scala语法的特性,我想知道Option在Scala中是否可以用OptionalJava 做些什么.

希望这不是一个愚蠢的问题,但每当我读到"强大的"时,问号就会浮现在我的头上.