doing an `fx` block with a single line `!` is the same as just pulling the thing you’re binding out...

# arrow

[pakoito]

doing an fx block with a single line ! is the same as just pulling the thing you’re binding outside

[Gopal S Akshintala]

Thanks, but I still have to repeat that effect { libDBClient.get().k().suspended() } in all my TCs, is there any way to abstract it out in common place, or is it inevitable?

[pakoito]

make a function out of it

[Gopal S Akshintala]

But the libDBClient type is not polymorphic

[pakoito]

fun <F> Observable<A>.toKind(): Kind<F, A> = effect { k().suspended() }

[pakoito]

fun <F> Mono<A>.toKind(): Kind<F, A> = effect { k().suspended() }

[pakoito]

the compiler will find the right specialisation

[pakoito]

override fun get(): Kind<F, String> = libDBClient.get().toKind()

[Gopal S Akshintala]

@pakoito I tried this, I hope this is what you meant

interface RepoTC<F> : Async<F> {
    fun get(): Kind<F, String>
    
    fun Mono<String>.toKind() = effect { k().suspended()!! }
    fun Single<String>.toKind() = effect { k().suspended() }
}

interface NonBlockingReactorRepo<F> : RepoTC<F> {
    val libDBClient: ReactorLibDBClient

    override fun get(): Kind<F, String> = libDBClient.get().toKind()
}

interface NonBlockingRxRepo<F> : RepoTC<F> {
    val libDBClient: RxLibDBClient

    override fun get(): Kind<F, String> = libDBClient.get().toKind()
}

[pakoito]

ye

[pakoito]

puttint toKind in RepoTC is kind of an API leak, I’d put them in a top-level object instead

[Gopal S Akshintala]

Thanks, better than before, but still some repetition, I think that can’t be avoided

[Gopal S Akshintala]

But then in the top level, the effect {} has to be different in both functions

[Gopal S Akshintala]

otherwise has this problem

[pakoito]

right, you need the effect function to come from async

[pakoito]

nevermind then 🙂

[Gopal S Akshintala]

Ok I think repeating effect in each Typeclass is the only way!

[Gopal S Akshintala]

@pakoito