小编Mar*_*lic的帖子

我只是从eta扩展中找到了一些间接线索

SimpleExpr :: = SimpleExpr1`_
'如果表达式_是方法类型或如果是按名字调用参数，则表达式_的格式正确。
如果是带有参数的方法，则_表示通过eta扩展转换为函数类型。
如果是类型=>的无参数方法或按名称调用参数，则_表示类型（）=>的函数，该函数评估何时将其应用于空的参数列表（）。

所以我猜eta是匿名函数表达的缩写吗？我对吗？

// Script A.scala
class A {
    private val privateVal = 1
}
object A extends App{ 
    println(new A().privateVal)
}

A.scala可以编译和运行，因为伴侣对象及其类可以访问彼此的私有成员，因此不会出现问题。

$ scalac A.scala
$ scala A
1

为什么在解释时相同的代码会显示伴随对象无法访问其伴随类中的私有val？

$ scala A.scala
error: value privateVal in class A cannot be accessed in A

我是猫和函数式编程的新手，我正在努力进行单元测试函数数据类型，如EitherT. 有示例代码：

class Library[F[_]]() {
    def create(book: Book)(implicit M: Monad[F]): EitherT[F, BookAlreadyExistsError, Book] = ...
}

我想使用 Spec2 对其进行测试，但我不知道如何正确进行。尝试过这样的事情，但它不起作用：

  val library = Library[IO]()

  test("create book") {

    val book = Book("Title 1", 2016, "author 1")
    (for (
      resultBook <- library.create(book)
    ) yield resultBook shouldEqual ???
    ).unsafeRunSync()

  }

我想有这样的非常简单的断言：

   resultBook shouldEqual Right(Book("Title 1", 2016, "author 1"))
   // or
   resultBook shouldEqual Left(BookAlreadyExistsError)

抽象成员方法在单例对象中是非法的

scala> object Foo {
     |   def g: Int
     | }
         def g: Int
             ^
On line 2: error: only traits and abstract classes can have declared but undefined members

as is 抽象值成员

scala> object Foo {
     |   val x: Int
     | }
         val x: Int
             ^
On line 2: error: only traits and abstract classes can have declared but undefined members

但是抽象类型成员在单例对象中是合法的

scala> object Foo {
     |   type A
     | }
object Foo

很明显，类型成员抽象的意义与其他抽象成员不同。有什么不同？抽象类型成员如何能有用，因为对象是最终的，它似乎无法具体化？

请考虑以下的基准，其分配List的String与长度为8的长度为1的

@State(Scope.Benchmark)
@BenchmarkMode(Array(Mode.Throughput))
class SoMemory {
  val size = 1_000_000
  @Benchmark def a: List[String] = List.fill[String](size)(Random.nextString(1))
  @Benchmark def b: List[String] = List.fill[String](size)(Random.nextString(8))
}

哪里sbt "jmh:run -i 10 -wi 10 -f 2 -t 1 -prof gc bench.SoMemory"给

[info] Benchmark                                     Mode  Cnt           Score          Error   Units
[info] SoMemory.a                                   thrpt   20          16.650 ±        0.519   ops/s
[info] SoMemory.a:·gc.alloc.rate                    thrpt   20        3870.364 ±      120.687  MB/sec
[info] SoMemory.a:·gc.alloc.rate.norm               thrpt   20   255963282.822 ±       61.012    B/op
[info] SoMemory.a:·gc.churn.PS_Eden_Space           thrpt   20        3862.090 ±      161.598 …

我有一些这样的代码，带有嵌套的迭代器。如果 find 返回和 Some(value)，我想停止，退出 foreach/map 和 return(value)，并继续 incase 的 None。这里的正确方法是什么？

编辑：这是完整的功能

Line Schema: line_id, name

Stop Schema: stop_id, x, y

Time Schema: line_id, stop_id, time

给定时间和 x,y 我想找到 line_id 和 name。所以暂时我坚持获取 valueWhichImTryingToGet。

  def findVehicle(time: String, x: String, y: String) = {
    val stopIter = Source.fromFile("stops.csv").getLines().drop(1)
    val stopCols = stopIter.map(_.split(",").map(_.trim))
    val stopIds = stopCols.filter(arr => arr(1) == x && arr(2) == y)

     val valueWhichImTryingToGet = stopIds.map { arr =>
      val iter = Source.fromFile("times.csv").getLines().drop(1)
      val cols = iter.map(_.split(",").map(_.trim))
      cols.find(col => col(1) …

我在 Scala 中有两个可变映射。

val oldMap = Map(10 -> 100, 20 -> 200, 30 -> 300)
val newMap = Map(10 -> 101, 20 -> 200, 30 -> 299, 40 -> 400)

我想合并newMap成oldMap得到outputMap如下具有从两个地图的所有键，但其值越大匹配键的值。

Map(20 -> 200, 40 -> 400, 10 -> 101, 30 -> 300)

我在下面尝试过并且它有效，但我想知道 Scala 的做法。

import scala.collection.mutable.Map

object Test extends App {

  val oldMap = Map(10 -> 100, 20 -> 200, 30 -> 300)
  val newMap = Map(10 -> 101, 20 -> 200, …

我有一个类似于下面的代码的 Scala 代码。在类/对象级别有一个隐式定义，我想用方法中定义的隐式“覆盖”它。（如果您真的需要知道，我需要ExecutionContext专门针对所讨论的方法更改我的内容）。

在这个例子中，我想在方法的范围内b用作隐式 for 。我怎样才能做到这一点？Intbar

object Foo {
  implicit val a: Int = 1
  def bar: Int = { // Didn't pass implicit Int parameter
    implicit val b: Int = 2
    implicitly[Int]
  }
}

这抱怨

错误：不明确的隐式值：Int 类型的对象 Foo 中的值 a 和 Int 类型的值 b 均匹配预期的 Int 类型

所以我认为 Scala 不能在隐式类范围和隐式方法范围之间进行选择。

我尝试在 Scala 函数参数名称中使用尾随下划线以避免与关键字冲突type，但出现错误：

Welcome to Scala 2.13.1 (Java HotSpot(TM) 64-Bit Server VM, Java 11.0.1).
Type in expressions for evaluation. Or try :help.


scala> def foo(type_: Char): Char = type_
                      ^
       error: ':' expected but identifier found.

scala>

我阅读了一些关于在 Scala 中使用下划线的解释，但没有一个提到我的情况

我有可选列表，例如：

val optionalEmptyList = Option(List[String]())

val optionalNonEmptyList = Option(List[String]("1","2"))

我想用 None 替换可选的空列表，同时保持可选的非空列表原样。

我想出了以下解决方案：

optionalEmptyList.flatMap(l => if (l.isEmpty) None else Option(l))

optionalNonEmptyList.flatMap(l => if (l.isEmpty) None else Option(l))

它有效，但似乎令人费解。有没有更简单的解决方案？