scala-cats

Here is some Scala cats code using the IO Monad : 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

Doobie book says that it's a good practice to return ConnectionIO from your repository layer. It gives an ability to chain calls and perform them in one transaction. Nice and clear. Now let's imagine we are working on REST API service and our scenario is: Find an object in database Perform some async manipulation (using cats.effect.IO or monix.eval.Task) with this object. Store the object in database. And we want to perform all these steps inside 1 transaction. The problem is that without natural transformation which is given for us by transactor.trans() we are working inside 2 monads - Task

Suppose I've got a list of functions List[A => B] and need a function that returns List[B] for a given value of type A : def foo[A, B](fs: List[A => B]): A => List[B] = a => fs.map(_.apply(a)) Is there any simpler (maybe with cats ) way to write List[A => B] => A => List[B] ? As @Oleg points out, you can use Applicative to generate the function: import cats.implicits._ def foo[A, B](fs: List[A => B]): A => List[B] = a => fs ap List(a) Although I don't think it makes much of a difference in this particular case. 来源： https://stackoverflow.com/questions/45160406/simple-way-to-apply-a-list-of

I'm using cats FreeMonad . Here's a simplified version of the algebra: sealed trait Op[A] object Op { final case class Get[T](name: String) extends Op[T] type OpF[A] = Free[Op, A] def get[T](name: String): OpF[T] = liftF[Op, T](Get[T](name)) } One of the interpreters will be a wrapper around a third-party library, called Client here which its get method's signature is similar to: class Client { def get[O <: Resource](name: String) (implicit f: Format[O], d: Definition[O]): Future[O] = ??? } My question is how can I encode that requirement in my implementation? class FutureOp extends (Op ~>

I've been messing around with some basic examples of Cats/Scalaz and also walking through tutorials to get a feel and I've hit a case which I'm sure there is a solution to. Is it possible to call a generalized function that takes a contextualized value ( F[A] ) with a Functor view ( F[_] : Functor ) with a context that is <: F ? I'm aware that Functor is invariant on type F[_] , and I'm also aware of the existence of Functor.widen , but it seems strange that there is no way to implicitly widen my type for use in a general function. An example in Cats (a similar example with Scalaz exists as