我只发现了几种无法进入的方法 - intersperseList.
为什么不可以访问？或者是否有某个功能可以进行散布操作？
ScalaZ的功能示例:
scala> intersperse(List(1, 2, 3), 7)
res3: List[Int] = List(1, 7, 2, 7, 3)
以下是使用IO Monad的一些Scala猫代码:
import java.util.concurrent.{ExecutorService, Executors}
import cats.effect.IO
import scala.concurrent.{ExecutionContext, ExecutionContextExecutor}
import scala.util.control.NonFatal
object Program extends App {
type CallbackType = (Either[Throwable, Unit]) => Unit
// IO.async[Unit] is like a Future that returns Unit on completion.
// Unlike a regular Future, it doesn't start to run until unsafeRunSync is called.
def forkAsync(toRun: () => Unit)(executor: ExecutorService): IO[Unit] = IO.async[Unit] { callback: CallbackType =>
// "callback" is a function that either takes a throwable (Left) or whatever toRun returns (Right). …我正在使用Scala Cats库中的State monad来以功能方式构成命令转换的命令式序列。
我的实际用例非常复杂，因此，为简化起见，请考虑以下最小问题：存在一种Counter状态，其计数值可能会递增或递减；但是，如果计数变为负数或溢出，则表示错误。万一遇到错误，我需要在发生错误时保留状态，并有效地停止处理后续的状态转换。
我使用type，使用每个状态转换的返回值报告任何错误Try[Unit]。成功完成的操作将返回新状态加该值Success(())，而失败将返回现有状态以及包装在其中的异常Failure。
注意：显然，遇到错误时，我可以抛出异常。但是，这将违反引用透明性，并且还需要我做一些额外的工作才能将计数器状态存储在抛出的异常中。我也打折了使用a Try[Counter]作为状态类型（而不是just Counter），因为我不能使用它来跟踪失败和失败状态。我尚未探讨的一种选择是使用(Counter, Try[Unit])元组作为状态，因为这似乎太麻烦了，但是我愿意提出建议。
import cats.data.State
import scala.util.{Failure, Success, Try}
// State being maintained: an immutable counter.
final case class Counter(count: Int)
// Type for state transition operations.
type Transition[M] = State[Counter, Try[M]]
// Operation to increment a counter.
val increment: Transition[Unit] = State {c =>
// If the count is at its maximum, incrementing it …当使用像Scala和的功能环境时cats-effect，是否应该使用效果类型来建模有状态对象的构造？
// not a value/case class
class Service(s: name)
def withoutEffect(name: String): Service =
new Service(name)
def withEffect[F: Sync](name: String): F[Service] =
F.delay {
new Service(name)
}
构造不是容易犯错的，因此我们可以使用较弱的typeclass，例如Apply。
// never throws
def withWeakEffect[F: Applicative](name: String): F[Service] =
new Service(name).pure[F]
我想所有这些都是纯粹的和确定性的。只是不是参照透明的，因为每次生成的实例都是不同的。那是使用效果类型的好时机吗？还是这里会有不同的功能模式？
我想使用Cats EitherT并OptionT处理该类型Future[Either[Error, Option[T]].假设有以下方法:
def findTeacher(id: Int): Future[Either[String, Option[Teacher]]]
def findSchool(teacher: Teacher): Future[Either[String, Option[School]]]
现在,如果我想随后在for-comprehension中调用它们,我可以使用EitherT并OptionT喜欢这样:
def getSchoolByTeacherId(id: Int): Future[Either[String, Option[School]]] = {
val result = for {
maybeTeacher <- EitherT(findTeacher(id))
schoolF = maybeTeacher.map(findSchool).getOrElse(Future.successful(Right(None)))
school <- EitherT(schoolF)
} yield {
school
}
result.value
}
我不知道是否有可能通过合并,使之更简洁,也许OptionT用EitherT？
我知道我可以遍历List小号
import cats.instances.list._
import cats.syntax.traverse._
def doMagic(item: A): M[B] = ???
val list: List[A] = ???
val result: M[List[B]] = list.traverse(doMagic)
我可以Seq来回转换List
val seq: Seq[A] = ???
val result: M[Seq[B]] = seq.toList.traverse(doMagic).map(_.toSeq)
但是我可以在Seq没有样板的情况下进行遍历吗？
val seq: Seq[A] = ???
val result: M[Seq[B]] = seq.traverse(doMagic)
或者,获取Traverse [Seq]实例的简单方法是什么？
我正在使用 doobie 查询一些数据，一切正常，如下所示：
case class Usuario(var documento: String, var nombre: String, var contrasena: String)
def getUsuario(doc: String) =
sql"""SELECT documento, nombre, contrasena FROM "Usuario" WHERE "documento" = $doc"""
.query[Usuario]
.option
.transact(xa)
.unsafeRunSync()
但是，如果我声明一个具有类型限制的函数，如下所示：
def getOption[T](f: Fragment): Option[T] = {
f.query[T]
.option
.transact(xa)
.unsafeRunSync()
}
我收到了这些错误：
Error:(42, 12) Cannot find or construct a Read instance for type:
T
This can happen for a few reasons, but the most common case is that a data
member somewhere within this type doesn't have …这个想法是能够对路由器服务上的 websocket 端点进行单元测试。任何其他类型的端点都可以很容易地使用 a 进行测试Request，但我无法找出一种轻松测试 websocket 响应的方法，因为使用 a 击中端点Request会给您一个 501 错误，因为您没有任何相应的套接字握手。
这是我正在使用的路由器
def router(averages: IO[SomeAverages]): HttpRoutes[F] =
HttpRoutes.of[F] {
case GET -> Root =>
val toClient: Stream[F, WebSocketFrame] = {
Stream
.awakeEvery[F](5.seconds)
.map(_ => {
val avg = averages.unsafeRunSync
WebSocketFrame.Text(avg.toString)
})
}
val fromClient: Pipe[F, WebSocketFrame, Unit] = _.evalMap {
case WebSocketFrame.Text(t, _) => F.delay(println(t))
case f => F.delay(println(s"Unknown type: $f"))
}
WebSocketBuilder[F].build(toClient, fromClient)
}
这个想法是让类似于下面的代码的东西与 websockets 一起工作
val server = Server.initServer[IO]
val router = server.router …我正在使用 Doobie，在我发现的示例中，它使用unsafeRunSync，例如：
sql"select name from country"
.query[String] // Query0[String]
.to[List] // ConnectionIO[List[String]]
.transact(xa) // IO[List[String]]
.unsafeRunSync // List[String]
.take(5) // List[String]
.foreach(println)
在底层，该函数的实现如下：
final def unsafeRunSync(): A = unsafeRunTimed(Duration.Inf).get
在文档中，我发现“请注意，此函数用于测试；它永远不应该出现在您的主线生产代码中！”。我想知道如果它unsafeRunSync在幕后使用这个功能，那么在生产中使用是否可以？
另外，如果不使用，如何设置执行超时unsafeRunTimed？
我正在尝试编写一些 Scala 代码以实现mtl 风格的自定义行为。例如，为了公开对特定效果进行抽象的“写入数据库”功能，我编写了自己的类型类：
trait CanPersist[M[_]]:
def persistToDB[A](a: A): M[Unit]
given CanPersist[IO] with
def persistToDB[A](a: A): IO[Unit] = IO(???) // Write to DB
IO 实例可以轻松实现，但我感兴趣的是自动为任何基于 IO 的 monad 堆栈提供实例：
// If a Transformer wraps a Monad that can persist then it can persist too
given persistTA[M[_]: CanPersist: Monad, T[_[_], _]: MonadTransformer]:
CanPersist[[A] =>> T[M, A]] with
def persistToDB[A](a: A): T[M, Unit] =
summon[MonadTransformer[T]].lift(summon[CanPersist[M]].persistToDB(a))
问题显然是 cats 没有定义自己的MonadTransformer类型类；幸运的是，自己编写非常简单：
trait MonadTransformer[T[_[_], _]]:
def lift[M[_]: Monad, A](ma: M[A]): T[M, A] …functional-programming scala monad-transformers scala-cats given
scala ×10
scala-cats ×10
cats-effect ×2
doobie ×2
given ×1
http4s ×1
implicit ×1
io-monad ×1
monads ×1
scalaz ×1
state-monad ×1
traversal ×1
unit-testing ×1
websocket ×1