标签: scala-cats

我有一个方法的结果: val res: Future[Int] Xor Future[String] = getResult(x)

并希望改造它并将其用作 Future[Int Xor String]

我无法从牧羊猫博客中推断我的用例,我不确定monad变换器是否是正确的工具,也许是某种形式的traverse？

Xor来自猫的任何分离.Scalaz \/或stdlib Either也可以(虽然我更喜欢有偏见的析取).

谢谢

我有一些返回IO的代码，但是我需要在http4s中使用效果。

import cats.effect.{Effect, IO}

class Service[F[_]: Effect] extends Http4sDsl[F] {
    val service: HttpService[F] = {
        HttpService[F] {
            case GET -> Root =>
                val data: IO[String] = getData()
                data.map(d => Ok(d))
        }
    }
}

给

[error]  found   : cats.effect.IO[F[org.http4s.Response[F]]]
[error]  required: F[org.http4s.Response[F]]
[error]         data.map(d => Ok(d))
[error]                 ^

我正在将fs2 0.10.x版本迁移到1.0.0版本。

我们的代码fs2.Scheduler从fs2版本0.10.x开始使用。

我不知道新的fs2版本1.0.0中的等效项是什么。

我在这里浏览了迁移指南，但是找不到从0.10.x到1.0.0或类似版本的迁移指南。

提前致谢。

为了使用circe 将JSON节点转换为JSON 以外的其他格式（例如XML，CSV等），我想出了一个解决方案，其中我必须访问circe的内部数据结构。

这是我的工作示例，该示例将JSON转换为XML字符串（虽然不完美，但您可以理解）：

package io.circe

import io.circe.Json.{JArray, JBoolean, JNull, JNumber, JObject, JString}
import io.circe.parser.parse

object Sample extends App {

  def transformToXMLString(js: Json): String = js match {
    case JNull => ""
    case JBoolean(b) => b.toString
    case JNumber(n) => n.toString
    case JString(s) => s.toString
    case JArray(a) => a.map(transformToXMLString(_)).mkString("")
    case JObject(o) => o.toMap.map {
      case (k, v) => s"<${k}>${transformToXMLString(v)}</${k}>"
    }.mkString("")
  }

  val json =
    """{
      | "root": {
      |  "sampleboolean": true,
      |  "sampleobj": {
      |    "anInt": 1,
      |    "aString": …

我正在尝试了解如何在scala中利用monad来解决简单的问题，以增强我的熟悉度。一个简单的问题是使用函数随机数生成器估算PI。我将在下面的代码中包含一个基于流的简单方法。

我正在寻求帮助，以将其转换为单子方法。例如，是否有惯用的方法以安全的方式将此代码转换为使用状态（和其他monad）？

trait RNG {
    def nextInt: (Int, RNG)
    def nextDouble: (Double, RNG)
}

case class Point(x: Double, y: Double) {
    val isInCircle = (x * x + y * y) < 1.0
}

object RNG {
    def nonNegativeInt(rng: RNG): (Int, RNG) = {
      val (ni, rng2) = rng.nextInt
      if (ni > 0) (ni, rng2)
      else if (ni == Int.MinValue) (0, rng2)
      else (ni + Int.MaxValue, rng2)
    }

    def double(rng: RNG): (Double, RNG) = {
      val (ni, rng2) = nonNegativeInt(rng) …

我写了这段代码，编译起来很好

for {
  list : List[Int] <- Future(List(1, 2, 3))
} yield list.size 

res7: Future[Int] = Future(Success(3))

但是如果我将此代码转换为

for {
  list : List[Int] <- IO(List(1, 2, 3))
} yield list.size

我收到一个编译时错误

value withFilter is not a member of cats.effect.IO[List[Int]]

如果我删除该类型，则可以正常编译

for {
  list  <- IO(List(1, 2, 3)) // returns IO[List[Int]]
} yield list.size 
res8: IO[Int] = Map(Delay(<function0>), <function1>, 0)

为什么不能使用IO指定类型？

我启用了部分统一，所以不能这样:)

如何在cat中实现以下循环？

首先（正常while（true）循环）：

while(true) { doSomething() }

第二个（while（true）循环递增）：

var i = 1
while(true) { i +=1; doSomething() }

第三（while（true）里面有几个自变量）：

var x = 1
var y = 2
while(true) {
  x = someCalculation()
  y = otherCalculation()
  doSomething()
}

是否有更好的方法在步骤之间传递状态。

例如，每次从卡组中取出一张卡时，我们都必须创建一个新的Deck并将其返回，以便下一步可以使用它，等等。

例如，是否有更好的方法使用Cats来做到这一点？

trait BlackjackSteps {
    def gamerTakesTwoCards(deck: Deck): (Gamer, Deck)
    def dealerTakesTwoCards(deck: Deck): (Dealer, Deck)
    def isBlackjack(gamer: Gamer, dealer: Dealer): Option[Player]
    def gamerToDrawCards(gamer: Gamer, deck: Deck): Gamer
    def dealerToDrawCards(dealer: Dealer, deck: Deck, gamer: Gamer): Dealer
    def determineWinner(gamer: Gamer, dealer: Dealer): Player
  }

游戏：

• 玩家与经销商玩
• 他们俩都抽了两张牌
• 如果没有21名获胜者
• 玩家保留抽牌直到17
• 最高得分不超过21分的玩家

编辑-----

感谢您的答复。我只想看看人们对这种方法的看法？

这个怎么样？

trait CardPicker {
    def pick(numberCards:Int): List[Card]
  }

  abstract class BlackjackSteps(cardPicker: CardPicker) {
    def gamerTakesTwoCards(gamer: Gamer): Gamer = {
      gamer.copy(cards = cardPicker.pick(2))
    }
    def dealerTakesTwoCards(dealer: Dealer): Dealer = { …

I have this:

Set[ValidatedNel[String, Double]] 

and I would like to sum the Doubles in it to get:

ValidatedNel[String, Double]

If some elements in the values are then I would like to have matching strings.

I played with Set.sum and Numeric to no avail...

Here is the test of what I would like to achieve:

  test("Summing ValidatedNel works") {
    val val1: ValidatedNel[String, Double] = Valid(1.0)
    val val2: ValidatedNel[String, Double] = Valid(2.0)
    val values: Set[ValidatedNel[String, Double]] = Set(val1, val2)

    val validatedNelNumeric: Numeric[ValidatedNel[String, …

我想知道如何在Scala中将List [Try [T]]转换为Try [List [T]]？

我已经尝试过使用累加器并向右折叠，但这似乎并不理想。