小编Dom*_*kis的帖子

如何为JSON实现自定义JodaTime的DateTime序列化器/解串器？我倾向于使用Play Framework的JSON库(2.1.1).有一个默认的DateTime序列化程序,但它使用dt.getMillis而不是.toString返回符合ISO标准的字符串.

写入读取[T]和写入[T]的案例类似乎相当简单,但我无法弄清楚如何为DateTime做同样的事情.

参数的默认值如何引用另一个参数？如果不能,如何解决？

case class A(val x:Int, val y:Int = x*2)

错误(合理地):

scala> case class B(val x:Int, val y:Int = x*2)
<console>:7: error: not found: value x
   case class B(val x:Int, val y:Int = x*2)
                                       ^

我有一个方法,根据谓词,将返回一个未来或另一个.换句话说,返回未来的if-else表达式:

extern crate futures; // 0.1.23

use futures::{future, Future};

fn f() -> impl Future<Item = usize, Error = ()> {
    if 1 > 0 {
        future::ok(2).map(|x| x)
    } else {
        future::ok(10).and_then(|x| future::ok(x + 2))
    }
}

这不编译:

error[E0308]: if and else have incompatible types
  --> src/lib.rs:6:5
   |
6  | /     if 1 > 0 {
7  | |         future::ok(2).map(|x| x)
8  | |     } else {
9  | |         future::ok(10).and_then(|x| future::ok(x + 2))
10 | |     }
   | |_____^ expected …

此答案指示如何转换java.util.concurrent.Future为scala.concurrent.Future,同时管理阻塞将发生的位置:

import java.util.concurrent.{Future => JFuture}
import scala.concurrent.{Future => SFuture}

val jfuture: JFuture[T] = ???
val promise = Promise[T]()
new Thread(
  new Runnable {
    def run() { promise.complete(Try{ jfuture.get }) }
  }
).start
val future = promise.future

我的问题与评论中提出的问题相同:

怎么了future { jfuture.get }？为什么你使用额外的线程与Promise结合？

答案如下:

它会在你的线程拉动中阻止线程.如果您为这样的期货配置了ExecutionContext,那很好,但是默认的ExecutionContext包含与处理器一样多的线程.

我不确定我理解这个解释.重申:

怎么了future { jfuture.get }？在手中创建一个新线程并在那里阻塞时,在未来内部是否阻塞？如果没有,它有什么不同？

目前,Gradle的scala集成不提供REPL功能.如何使用适当的类路径从Gradle以符合人体工程学的方式运行Scala REPL？

怎么会Future[Option[X]]变成Option[Future[X]]？

val futOpt:Future[Option[Int]] = future(Some(1))
val optFut:Option[Future[Int]] = ?

更新:

这是对这个问题的跟进.我想我正试图抓住优雅地改造嵌套的未来.我试图与实现Option叫什么是可以做到Sequences,在那里你转Future[Seq[Future[Seq[X]]]]成Future[Future[Seq[Seq[x]]]],然后flatMap将双层.正如Ionut澄清的那样,我已经按照翻转的顺序表达了这个问题,它应该是Option[Future[X]]- > Future[Option[X]].

正如您在下面看到的,在序列化和反序列化之后,您将获得据称不同的DateTime实例:

scala> import org.joda.time.DateTime
import org.joda.time.DateTime

scala> val a = new DateTime()
a: org.joda.time.DateTime = 2014-01-08T19:00:08.883+02:00

scala> val b = DateTime.parse(a.toString())
b: org.joda.time.DateTime = 2014-01-08T19:00:08.883+02:00

scala> a == b
res0: Boolean = false

根据AbstractInstant的javadoc,equals"基于毫秒时刻,时间顺序和时区,将此对象与指定对象进行相等性比较." 所以这不应该发生吗？我错过了什么？

从Scala中的集合中获取随机元素的有效方法是什么？这里有一个相关的问题,但正如其中一条评论指出的那样,"[那个]问题没有说明任何效率需求".

下面是包含时区信息的ISO8601日期字符串的反序列化.请注意,时区信息丢失:

scala> val date1 = new DateTime().withZone(DateTimeZone.forID("Europe/Berlin"))
date1: org.joda.time.DateTime = 2013-09-22T18:42:15.348+02:00

scala> date1.getZone()
res45: org.joda.time.DateTimeZone = Europe/Berlin

scala> val date2 = new DateTime(date1.toString())
date2: org.joda.time.DateTime = 2013-09-22T19:42:15.348+03:00

scala> date2.getZone()
res46: org.joda.time.DateTimeZone = Europe/Vilnius

scala> date1.getZone() == date2.getZone()
res47: Boolean = false

时区信息(UTC偏移)被序列化,如ISO8601字符串中+03:00和+02:00结尾处,但在反序列化后丢失.正如你所看到的date2DateTime对象,这是我预计的副本date1有系统的UTC偏移量,而不是+02:00,它date1有.

如何反序列化ISO8601字符串以保留UTC偏移量？

如何转化Future[Option[Future[Option[X]]]]为Future[Option[X]]？

如果它是一个TraversableOnce而不是Option我使用Future伴侣对象 ; 但是选项怎么样？

例:

def processAndReturnFuture(x:String):Future[String] = future(x)
def processAgainAndReturnOption(x:String):Option[String] = Some(x)

val futOpt:Future[Option[String]] = future(Some("x"))
val futOptFutOpt:Future[Option[Future[Option[String]]]] =
  futOpt.map( opt =>
    opt.map( x =>
      processAndReturnFuture(x).map( processedX =>
        processAgainAndReturnOption(processedX)
      )
    )
  )