标签: scala-cats

我有以下情况,给出两种类型,MA并且MB,我希望能够证明它们不仅具有一个,Applicative而且它们都具有相同的底层形状.我尝试过以下操作:

type UnapplyM[TC[_[_]], MA, M0[_]] = Unapply[TC, MA]{ type M[X] = M0[X] }

implicit def thing[MA, MB, M[_]](implicit un: UnapplyM[Applicative,MA,M], un2: UnapplyM[Applicative,MB,M]) = ...

但是继续遇到不同的含义(即这不起作用.)A类型参数Unapply和工作类型投影可以做类似的事情.

这有一种方法可以采用这两种类型并且能够证明它们实际上是由同一类型类实例支持的吗？

我有一个实例,Either[Future[A], Future[B]]我想将其转换为Future[Either[A, B]].

自从我上一个问题以来,已经发布了cat 0.8.1,改变了库的结构并Xor倾向于支持Either,这在2.12中是正确的.

因此,先前接受的答案中描述的方法不再起作用.我试图找到合适的进口但失败了.

cats.instances.either._
cats.implicits._ 
cats.syntax.bitraverse._

看起来似乎有道理,但不幸的是不起作用.编译仍然失败value bisequence is not a member of Either[scala.concurrent.Future[A],scala.concurrent.Future[??B]]

扩展导入*.all._并没有改变编译器错误.

我在scala 2.11.8上,因为项目所依赖的所有库都没有发布2.12版本

如何M在下面的方法中使用for-comprehension类型？

def foo[M[_]: Monad](m1: M[Int], m2: M[Int]) =
  for {
     a <- m1
     b <- m2
  } yield (a + b)

我会得到一个

value flatMap is not a member of type parameter M[Int]

我可以通过定义flatMap和map方法来使它工作:

implicit class MOps[A](m: M[A])(implicit monad: Monad[M]) {
  def flatMap[B](f: A => M[B]): M[B] = monad.flatMap(m)(f)
  def map[B](f: A => B): M[B]        = monad.map(m)(f)
}

但是肯定有必要让Cats提供这些方法吗？

我想组合多个IO应该并行独立运行的值.

val io1: IO[Int] = ???
val io2: IO[Int] = ???

在我看来,我必须选择:

1. 使用带有叉形连接图案的cats-effect纤维

   val parallelSum1: IO[Int] = for {
     fiber1 <- io1.start
     fiber2 <- io2.start
     i1 <- fiber1.join
     i2 <- fiber2.join
   } yield i1 + i2
   

   Run Code Online (Sandbox Code Playgroud)
2. 使用Parallel实例IO与parMapN(或它的兄弟姐妹等中的一种parTraverse,parSequence,parTupled等)

   val parallelSum2: IO[Int] = (io1, io2).parMapN(_ + _)
   

   Run Code Online (Sandbox Code Playgroud)

不确定每种方法的优缺点,何时我应该选择其中一种方法.当抽象出效果类型IO(无标签 - 最终样式)时,这变得更加棘手:

def io1[F[_]]: F[Int] = ???
def io2[F[_]]: F[Int] = ???

def parallelSum1[F[_]: Concurrent]: F[Int] = for …

import cats._
import cats.implicits._

trait Console[F[_]]{
  def readInput() : F[Int]
  def print(msg: String) : F[Unit]
} 

class Foo {
  def doFoo[F[_]: Monad](number: Int)(implicit C: Console[F]) : F[Unit] = {
    C.readInput().flatMap{input => 
      if (input == number) C.print("you won").map(_ => ())
      else if (input > number) C.print("you guessed too high").flatMap(_ => doFoo(number))
      else C.print("you guessed too low").flatMap(_ => doFoo(number))
    }
  }
} 

但是我从编译器中得到了这个神秘的错误

cmd18.sc:5: ambiguous implicit values:
 both value catsStdInstancesForList in trait ListInstances of type => cats.Traverse[List] with cats.Alternative[List] with cats.Monad[List] with …

标准库提供以下unzip方法List：

scala>val l = List((1, "one"), (2, "two"), (3, "three"), (4, "four"), (5, "five"))

scala> l.unzip
// res13: (List[Int], List[String]) = (
//  List(1, 2, 3, 4, 5),
//  List("one", "two", "three", "four", "five")
//)

有没有一种方法可以NonEmptyList从cats库中实现相同目的：

scala> import cats.data.NonEmptyList

scala> val nel = NonEmptyList.of((1, "one"), (2, "two"), (3, "three"), (4, "four"), (5, "five"))
//res15: NonEmptyList[(Int, String)] = NonEmptyList(
//  (1, "one"),
//  List((2, "two"), (3, "three"), (4, "four"), (5, "five"))
//)

说我有三个数据库访问功能foo,bar以及baz可在每个返回Option[A],其中A一些模型类,并调用互相依赖.

我想按顺序调用函数,并且在每种情况下,如果找不到值,则返回相应的错误消息(None).

我当前的代码如下所示:

Input is a URL: /x/:xID/y/:yID/z/:zID

foo(xID) match {
  case None => Left(s"$xID is not a valid id")
  case Some(x) =>
    bar(yID) match {
      case None => Left(s"$yID is not a valid id")
      case Some(y) =>
        baz(zID) match {
          case None => Left(s"$zID is not a valid id")
          case Some(z) => Right(process(x, y, z))
        }
    }
}

可以看出,代码严重嵌套.

相反,我使用for理解,我不能给出具体的错误信息,因为我不知道哪一步失败了:

(for {
  x <- foo(xID) …

以下是使用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来以功能方式构成命令转换的命令式序列。

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 …