小编Mar*_*lic的帖子

我有一个带有单元测试的无标签最终实现，当我运行单元测试时，仅第一步被调用，其余部分不被调用。

这是测试目标：

class NameThing[F[_]: Monad](implicit console: Console[F]) {

  def program: F[Unit] = for {
    _ <- console.prompt
    rawName <- console.read
    fullName = parse(rawName)
    _ <- console.display(fullName)
  } yield ()

  def parse(rawName:String):FullName = {
    val parts = rawName.split(" ")
    FullName(parts(0), parts(1))
  }
}

单元测试是：

implicit object TestConsole extends Console[Test] {
      override def prompt: Test[Unit] = {
        println("ok1")
        Reader(TestEnv => TestEnv.prompt)
      }
      override def read: Test[String] =  {
        println("ok2")
        Reader(TestEnv => TestEnv.read)
      }
      override def display(fullName: FullName): Test[Unit] = {
        println("ok3")
        Reader(TestEnv …

I have implemented Sphere function (takes a List of elements, squares every element and returns sum) in Scala. I want to convert this function to tail recursive. My code is here

def Sphere(list: List[Double]): Double = {
  val power = list.map(math.pow(_, 2))
  power.reduce(_+_)
}

我有一个从 getProductSettingsMethod 返回的 Future [ProductSettings]。现在我需要 ClearCanLoad 字段中的 true 或 false

   def getEmployerProductSettingsQuery(employer: Employer): DBIOAction[ProductSettings, NoStream, Effect.Read] = {
val productSettingsQ = productSettingsQuery.filter(_.employerId === employer.id).result
productSettingsQ.map(_.headOrServerException(s"Could not find ProductSettings for employer ${employer.id}"))
 }

   def getEmployerProductSettings(employer: Employer): Future[ProductSettings] =
db.run(getEmployerProductSettingsQuery(employer))

我尝试了 .map、filter、flatMap 等，但没有一个起作用

def cleared (employer : Employer) :Boolean = {
val f : Future[ProductSettings] = 
 getEmployerProductSettings(employer)

  val iscleared: Boolean = f.filter { x =>
    x.clearedCanLoadSpenditCards match {
      case true =>
        true
      case false =>
        false
    }
  }

}

这不起作用，过滤器也不起作用

val f …

在Scala中，对于包含要分解的数组的case类，是否可以更有效地使用平面地图？

这是一个有效的代码，但看起来不正确：

object stuff {
    def main(args: Array[String]): Unit = {
        case class Stuff(name: String, stuff: Seq[String])
        case class FlatStuff(name: String, stuff: String)

        val someStuff = Array(Stuff("a", Seq("1", "2", "3")), Stuff("b", Seq("4", "5")))

        val stuffs = someStuff.flatMap(item => {
            val flatten = new Array[FlatStuff](item.stuff.length)
            for (i <- 0 until item.stuff.length) {
                flatten(i) = FlatStuff(item.name, item.stuff(i))
            }
            flatten
        })

        stuffs.foreach(stuff => println(stuff))
    }
}

我正在尝试测试一些代码，Mockito.spy用于为我需要提供的某些功能提供行为。虽然我知道我正在做的事情可能有更好的替代方案，但我很好奇为什么下面的代码NullPointerException在 Scala 中抛出 a以及如何解决它。

该类Foo正在测试中。它包含一个方法act，就这个问题而言，它只计算数字的总和。ClassFooSpec是class的相应单元测试Foo。ClassBar是另一个类，用作 class 的参数Foo以演示出现异常的情况。

以下代码有效。方法不Foo.act接受任何参数。

package foo

import org.mockito.Matchers.any
import org.mockito.Mockito.{spy, times, verify, when}
import org.scalatest.WordSpec
import org.scalatest.mockito.MockitoSugar

class Foo {
  def act(): Int = {
    (1 to 10).sum
  }
}

class FooSpec extends WordSpec with MockitoSugar {
  "a test" in {
    val spiedFoo = spy(new Foo)
    when(spiedFoo.act()).thenReturn(100)

    val result = spiedFoo.act()

    assert(result == 100)
    verify(spiedFoo, times(1)).act() …

我是Scala的新手，我正在尝试对其结构进行解码，我了解了模式匹配，并且语法类似于Java switch语句

val x: Int = Random.nextInt(10)

x match {
  case 0 => "zero"
  case 1 => "one"
  case 2 => "two"
  case _ => "other"
}

这段代码非常明显并且可读。我遇到了很明显的部分函数，清楚了它们是什么

偏函数是一种不能为每个可能的输入值都提供答案的函数。

我感到困惑的是case在这样的部分函数的主体中使用：

val divide2: PartialFunction[Int, Int] = {
    case d: Int if d != 0 => 42 / d // WHAT IS THIS ?! 
}

我不明白怎么case没有用match的语句，请问这是由Scala中，它是如何读取解释，它是一个方法，一个类或其他结构？我可以用什么其他的方法case，而不match声明

编辑：

我尝试过这种情况，但还是不明白。例如

val SomeFun: PartialFunction[Int, Int] = {
    case d: Int if …

我只是从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

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