小编Mic*_*jac的帖子

如果我们有一个接受匿名函数A => B作为参数的方法,我们可以A在调用中隐式.

def impl(a: Int)(f: Int => Int): Int = f(a)

impl(a) { implicit z =>
    ...
}

但是我们可以使用具有多个参数的匿名函数来执行此操作吗？

def impl(a: Int, b: Int)(f: (Int, Int) => Int): Int = f(a, b)

理想情况下,这将工作如下:

impl(1, 2) { implicit (a, b) => // wrong
    ...
}

要么

impl(1, 2) { (implicit a, implicit b) => // also wrong
    ...
}

我可以使用A => B => C相反的方法解决这个问题:

def impl(a: Int, b: Int)(f: Int => Int => Int): …

下列:

val add = (a: Int, b: Int) => a + b 

转换为:

object add extends Function2[Int, Int, Int] {
  def apply(a: Int, b: Int) = a + b
}

而

val a1 = add(_: Int, 3)

转换为:

object a1 extends Function1[Int, Int] {
  def apply(x: Int): Int = {
    add(x, 3)
  }
}

但当我这样做时:

scala> val a2 = add _
a2: () => (Int, Int) => Int = <function0>

然后调用a2,它会抛出一个错误:

scala> a2(1, 2) 
<console>:11: error: too many …

考虑供应商API提供的以下JSON:

import play.api.libs.json._
import play.api.libs.json.Reads._
import play.api.libs.functional.syntax._

val json = Json.parse(
  """
    |{
    |  "returns": {
    |    "markets" : {
    |      "ABC" : {
    |        "label": "ABC",
    |        "id":1
    |      },
    |      "DEF" : {
    |        "label": "DEF",
    |        "id":2
    |      }
    |    }
    |  }
    |}
  """.stripMargin)

如何提取与"label"和"id"字段相关的一系列对.从这块JSON中我得到的结果是:

Seq((1,"ABC"),(2,"DEF"))

我没有构建一个正确的JsPath提取器,因为它期望一个匹配,例如

val jsonTransformer = (__ \ 'returns \ 'markets).json.pick
json.transform(jsonTransformer)

我想获得一个代码示例,它可以完成优先级队列中项目的升序排序.

我想存储Tuple2(Int, String)在优先级队列中,以便按元组的第一个元素按升序排序.如果我的优先级队列被调用pq,我打电话,pq.head我想得到数量最少的元组,同样的调用pq.dequeue.

scala> val pq = scala.collection.mutable.PriorityQueue[(Int, String)]()
pq: scala.collection.mutable.PriorityQueue[(Int, String)] = PriorityQueue()

scala> pq += Tuple2(8, "eight")
res60: pq.type = PriorityQueue((8,eight))

scala> pq += Tuple2(4, "four")
res61: pq.type = PriorityQueue((8,eight), (4,four))

scala> pq += Tuple2(7, "seven")
res62: pq.type = PriorityQueue((8,eight), (4,four), (7,seven))

如何在插入上面的第一个元素应用升序？

谢谢

考虑这个简单的类:

class MyClass(p: (String, String) *) {
    val params: Map[String, String] = p.toMap
}

还有一个扩展它的类:

class SomeOtherClass(p: (String, String) *) extends MyClass(p: _*)

我想删除构造函数,MyClass以避免在扩展它的所有内容中携带初始化参数(可能有很多类型).相反,我更喜欢扩展类型的伴随对象MyClass继承某种构建器方法.

class MyClass {
    val param = Map.empty[String, String] // some member with a default value
}

trait MyClassBuilder[A <: MyClass] {
    def apply(p: (String, String) *): A = ???
}

基本上apply应该做这样的事情:

new A {
    override val param = p.toMap
}

显然,上面的代码无法正常工作.我们的想法是使用这样的子类型:

class SomeOtherClass extends MyClass
object SomeOtherClass extends MyClassBuilder[SomeOtherClass] { …

光滑的旋转木马是否有办法与zepto.js一起使用？我想使用zepto,因为这是一个移动应用程序,需要一个比jquery更小的库加载.

我想上传一个文件，然后将该文件保存到数据库中。我正在使用播放框架和光滑。我找不到任何示例如何编写tablequery以及如何在我的数据库中保存文件（Postgres）。

Play文档描述了如何上传文件的方式：

def upload = Action(parse.multipartFormData) { request =>
  request.body.file("picture").map { picture =>
    import java.io.File
    val filename = picture.filename
    val contentType = picture.contentType
    val file = picture.ref.file

    //Here I have to save file, right?

    Ok("File uploaded")
  }.getOrElse {
    Redirect(routes.Application.index).flashing(
      "error" -> "Missing file")
  }
}

有人可以给我一个例子或提示去哪里看看吗？我不确定模型的数据类型是什么。

可以这么说，有一个PictureDao：

trait PictureDao with PictureComponent with HasDatabaseConfig[JdbcProfile] {
  import driver.api._

}

trait PictureComponent {
  protected val dbConfig = DatabaseConfigProvider.get[JdbcProfile]("postgres")(Play.current)
  protected val driver: JdbcProfile
  import driver.api._
  import com.github.tototoshi.slick.JdbcJodaSupport._

  class PictureTable(tag: Tag) extends Table[Picture](tag, "picture") { …

我有两个类，将它们称为Foo和Fizz。Foo使用一个被调用的注释宏expand来为其某些方法创建别名（实际实现所做的不仅仅是创建别名，但简单版本仍然会出现以下问题）。为简单起见，假设expand宏简单地获取带注释的类中的所有方法，并制作它们的副本，将“Copy”附加到方法名称的末尾，然后将调用转发到原始方法。

我的问题是，如果我使用expand宏 on Foo，它会创建一个Foo#bar名为的方法的副本barCopy，当barCopy在另一个类中调用时Fizz，一切都会编译，但 scaladoc 生成失败，如下所示：

[error] ../src/main/scala/Foo.scala:11: value barCopy is not a member of Foo
[error]     def str = foo.barCopy("hey")
[error]                   ^
[info] No documentation generated with unsuccessful compiler run

如果我删除标记正在复制的方法 ( Foo#bar)的 scaladoc ，该sbt doc命令将再次运行。就好像 scaladoc 生成器在不使用启用的宏天堂插件的情况下调用编译器的早期阶段一样，但如果从有问题的方法中删除文档，它会以某种方式工作。

这是expand宏：

import scala.annotation.{ StaticAnnotation, compileTimeOnly }
import scala.language.experimental.macros
import scala.reflect.macros.whitebox.Context

@compileTimeOnly("You must enable the macro …

val future = Future {
   println("hello")
   Thread.sleep(2000)
}

future.onComplete(_ => println("done"))

上面的代码在以后的代码块中。

我的问题是：由于Future使用了ExecutionContext。这是否意味着该线程池中的某些线程在执行其中的代码时会被将来阻塞？

到底哪个线程会调用回调？来自线程池的另一个线程？它将如何发现在此将来执行的代码已完成？

我有一系列的错误或观点(Seq[Xor[Error,View]])

我想将此映射到第一个错误的Xor(如果有)或视图序列(Xor[Error, Seq[View]])或可能只是(Xor[Seq[Error],Seq[View])

我怎样才能做到这一点？