Yeah I have an aws client as resource that is pushed in from the top level. I need to use that resource in my business logic. One part of the business logic can be executed concurrently (which makes use of the above resource). So I want the resource to be freed only when the concurrent task also is completed. What are other options than start? I tried
background get back the concurrent execution as a resource. That also is not completing the work somehow.
Does it have to be released before your app closes? Not appropriate to open/close on init/shutdown?
If it's something like an http4s client, you absolutely want one for the whole process lifetime
because the resource is expensive to construct, and what it gives you is more efficient per-usage actions
(it does connection pooling, keep-alive, etc)
most resources you want to construct once and then pass down to your app already-alive
it's relatively rare that you really want to be dealing with
Resource inside your biz logic
I'm aware of
cats-mtl, but what if you need to eventually provide a context and convert reader-like G to a non-reader F?
i usually use the former, and usually add
trait Train[F[_]] {
def toot(): F[Unit]
def mapK[G[_]](f: F ~> G): Train[G]
}(cats-tagless can auto-generate these also)
sorry, i must be missing something
there's using
Kleisli vs. ApplicativeAsk, that's one choice
I'm now working in a project where "tagless-final-to-the-max" approach was taken.
There is always different types for
Lots of custom
Oh, and it uses doobie, so add another two types - one is instantiated to
There is always different types for
Fs with different contexts.Lots of custom
Lift/Unlift classes for conversion back and forth.Oh, and it uses doobie, so add another two types - one is instantiated to
ConnectionIO and second to Kleisli[ConnectionIO, ...], both with its own lifts-unlifts
So I wanted to know if its usual approach or not
is there some intermediate type like
class BizLogic[F[_]](alg1: Alg1[F], alg2[Kleisli[F, Dependency]])? because something like that would be difficult.
or at least more complicated than it probably should be. but i'm just guessing because i'm not sure of the structure you are describing.
typical signature is
def withRequestId[F[_], G[_] : WithRun[*[_], F, RequestId[F]](routes: HttpRoutes[F]): HttpRoutes[G]
i see now what you're saying about monad transformers vs. typeclass constraints.
the former is more flexible, although it is likely that only Kleisli has a WithRun instance i'm guessing.
it's a familiarity issue, like you said. i think more folks would understand the Kleisli version since it is more "concrete"
so... i feel ya.
there's the evalMap(f: A => F[B]): Resource[F, A] => Resource[F, B] = _.flatMap(a => Resource.liftF(f(a))) combinator that lifts the output of f into an "inner" Resource.
what about a different combinator that uses the first Resource to create the next, where the first can be released: evalUse(f: A => F[B]): Resource[F, A] => Resource[F, B] = rfa => Resource.liftF(rfa.use(f))?
or is there a better way?
@keirlawson example integration with scalatest here https://gist.github.com/Daenyth/67575575b5c1acc1d6ea100aae05b3a9
