我有关于Xor猫对象的这段代码
Xor.right(data).ensure(List(s"$name cannot be blank"))(_.nonEmpty)
现在,因为Xor已被删除,我正在尝试使用Either对象编写类似的东西
Either.ensuring(name.nonEmpty, List(s"$name cannot be blank"))
但这不起作用,因为确保的返回类型是 Either.type
我可以写一个if.但我想用猫结构进行验证.
我有一些"遗留的"Scala代码(类似Java),它可以进行一些数据访问.有一个装饰器跟踪DAO方法的使用(收集指标),如下所示:
class TrackingDao(tracker: Tracker) extends Dao {
def fetchById(id: UUID, source: String): Option[String] = {
tracker.track("fetchById", source) {
actualFetchLogic(...)
}
}
...
}
我试图把它塑造成一个免费的monad.我为DAO操作定义了以下代数:
sealed trait DBOp[A]
case class FetchById(id: UUID) extends DBOp[Option[String]]
...
我看到两个选择:
a)我可以制作两个解释器DBOp,一个执行实际数据访问,另一个执行跟踪,并将它们组合在一起或者
b)我使跟踪成为一个显式代数,并使用Coproduct在同一个for组合中使用它们或者
c)完全不同的东西!
第一个选项看起来更像是一个"装饰器"方法,它与DBOp第二个选项相关,第二个选项是更通用的解决方案,但需要明确地调用"跟踪"代数.
另外,请注意source原始fetchById呼叫上的参数:它仅用于跟踪.我更愿意从API中删除它.
这是实际问题:如何建模跟踪？
我有不同类型的期货。
import cats.Cartesian
import cats.instances.future._
import cats.syntax.cartesian._
import scala.concurrent.Future
import cats.implicits._
val aF : Future[Either[X, Y]] = getFuture(...)
val bF : Future[Either[X, Y]] = getFuture(...)
val cF = Future[List[Long]] = getFuture2(...)
val combinedFuture = Cartesian.tuple3(aF, bF, cF)
combinedFuture match {case (a, b, c) =>
...
}
但我得到一个错误
Error:(36, 44) could not find implicit value for parameter cartesian: cats.Cartesian[scala.concurrent.Future]
val combinedFuture = Cartesian.tuple3(aF, bF, cF)
但是正如您所看到的，我已经导入了所有隐式，intances.future._和语法。
我在Scala 2.11.8上使用Cats 0.9.0
我正在将Future代码转换为IO。我有类似的代码
def doSomething: Future[Foo] = {
Future {
//some code the result of which we don't care about
}
Future {
//Foo
}
}
然后在程序结束时，我doSomething.unsafeRunSync。我如何将这些Futures 转换为IOs，同时保持第一个的即发即弃功能Future？在使用IO的异步API，我担心发生意外拦截时，我再打线程unsafeRunSync上doSomething。
我正在阅读Herding Cats
排序列表中的Traverse页面上的最后一个示例对我来说都失败了.
在示例中,他们这样做: -
scala> List(Right(1): Either[String, Int]).sequence
res5: Either[String,List[Int]] = Right(List(1))
scala> List(Right(1): Either[String, Int], Left("boom"): Either[String, Int]).sequence
res6: Either[String,List[Int]] = Left(boom)
但是当我尝试时,我收到以下错误: -
scala> import cats._, cats.data._, cats.implicits._
scala> val les = List(Right(3):Either[String,Int], Right(2):Either[String,Int])
scala> les.sequence
<console>:37: error: Cannot prove that Either[String,Int] <:< G[A].
les.sequence
^
但是当我用类型别名帮助编译器来修复Left类型时,一切都很好: -
scala> type XorStr[X] = Either[String,X]
defined type alias XorStr
scala> val les = List(Right(3):XorStr[Int], Right(2):XorStr[Int])
les: List[XorStr[Int]] = List(Right(3), Right(2))
scala> les.sequence
res0: XorStr[List[Int]] = Right(List(3, …我在Scala做了一些工作人员并遇到了implicit实例问题.让我们考虑以下示例:
import cats.{Applicative, FlatMap, Monad}
import cats.syntax.functor._
import cats.syntax.flatMap._
import cats.syntax.applicative._
class Test[F[_]: Monad] extends App{
val t1 = ().pure[F]
val t2 = ().pure[F]
def testFlatApplicative: F[Unit] =
for{
_ <- t1
_ <- t2
} yield ()
}
编译好了.但由于cats.Monad[F[_]]声明如下:
@typeclass trait Monad[F[_]] extends FlatMap[F] with Applicative[F]
我希望以下内容也能正常运行
import cats.{Applicative, FlatMap, Monad}
import cats.syntax.functor._
import cats.syntax.flatMap._
import cats.syntax.applicative._
class Test[F[_]: FlatMap : Applicative] extends App{
val t1 = ().pure[F]
val t2 = ().pure[F]
def testFlatApplicative: F[Unit] …import cats.data.ReaderT
import cats.instances.either._
trait Service1
trait Service2
case class Cats(name:String)
type FailFast[A] = Either[List[String], A]
type Env = (Service1, Service2, Cats)
type ReaderEnvFF[A] = ReaderT[FailFast, Env, A]
def toReaderEnvFF[A](input:A):ReaderEnvFF[A] =
ReaderT((_:Env) => Right(input))
def c:ReaderEnvFF[Cats] =
for {
cats <- toReaderEnvFF((_:Env)._3)
} yield cats // This line is 26
错误：
错误：（26，11）类型不匹配；找到：T1.this.Env => com.savdev.Cats（展开为）（（（com.savdev.Service1，com.savdev.Service2，com.savdev.Cats）））=> com.savdev.Cats需要的猫：com .savdev.Cats}产生猫
您能解释一下，为什么猫不是com.savdev.Cats吗？以及为什么在错误中说它被扩展为具有return方法的功能[Cats]，而不是botFailFast[Cats]
我尝试应用与此处完全相同的逻辑：
trait Service1 { def s1f = Option(10) }
trait Service2 {
type ReaderS1[A] = ReaderT[Option,Service1,A]
import cats.syntax.applicative._ …type MapReaderOrOption[A] = ReaderT[Option, Map[String,String], A]
我可以从创建它ReaderT.apply：
def f:MapReaderOrOption[Int] = ReaderT(_ => Option(10))
从A类型通过类型丰富和纯方法：
import cats.Applicative
import cats.syntax.int._
def f:MapReaderOrOption[Int] = 10.pure[MapReaderOrOption]
我想找到类似的东西。每次使用ReaderT（..）都不那么方便。当然，我可以创建一个辅助方法。问题是，还有其他选择吗？
预期类似：
def f:MapReaderOrOption[Int] = Option(10).asReaderT[MapReaderOrOption]
我正在与猫打交道，我想将其转换val x: State[A, B]为猫StateT[IO, A, B]。注意：IO来自猫的效果。
如何优雅地做到这一点？
ScalaZ和Cats都具有类型类和数据类型的概念。
尽管我了解类型类和类型类实例，但我不理解它们对术语“数据类型”的使用。
类似Kleisi或Either称为“数据类型”的东西 -为什么？我的理解是，它们是使用这些类型类“可能”实现的通用功能，但是，即使在Scala的FP Programing一书中，它们也不被称为“数据类型”。
我想知道这个词是从哪里来的？
例子：