kotlinlang #arrow-contributors

@PublishedApi internal object Function1FunctorInstance_ : Function1FunctorInstance<Any?>

@InlineOnly
inline fun <I, A, B> Kind<Function1PartialOf<I>, A>.map(noinline f: (A) -> B): Function1<I, B> = 
    with(Function1FunctorInstance_ as Function1FunctorInstance<I>) { this@map.map(f) }

fun test(): Function1<String, Double> = 
    fun(it: String): Int { return it.length }
        .k()
        .let { it as Kind<Function1PartialOf<String>, Int> } // just to show we're using our extension!
        .map { it.toDouble() }

Eugenio

07/21/2018, 10:07 PM

ah, I did find a limitation of the previous approach to get the instance: for example, getting an instance of

KClass<Function1PartialOf<*>>

doesn't work with

Function1PartialOf::class

Eugenio

07/21/2018, 10:08 PM

but this works:

Copy code

@InlineOnly
@JvmName("instanceFunctor<Function1PartialOf>")
inline fun <I> KClass<Functor<*>>.function1PartialOf(): Function1FunctorInstance<I> =
    Function1FunctorInstance_ as Function1FunctorInstance<I>

val instance = Functor::class.function1PartialOf<String>()

Eugenio

07/21/2018, 10:09 PM

I mean you could use

Function1

directly 🤔

Eugenio

07/21/2018, 10:11 PM

like this:

Copy code

@InlineOnly
@JvmName("instanceFunctor<Function1>")
inline infix fun <I> KClass<Functor<*>>.of(type: KClass<Function1<*, *>>): Function1FunctorInstance<I> =
    Function1FunctorInstance_ as Function1FunctorInstance<I>

val instance: Functor<Function1PartialOf<String>> = Functor::class of Function1::class

Eugenio

07/21/2018, 10:13 PM

Copy code

val instance = Functor::class.of<String>(Function1::class)

Eugenio

07/21/2018, 10:41 PM

last question (then I'm going to sleep): why does the

@higherkind

annotation only create a single "partial of" typealias, instead of going all the way down?

Copy code

typealias Tuple10Of<A, B, C, D, E, F, G, H, I, J> = arrow.Kind10<ForTuple10, A, B, C, D, E, F, G, H, I, J>
typealias Tuple10PartialOf<A, B, C, D, E, F, G, H, I> = arrow.Kind9<ForTuple10, A, B, C, D, E, F, G, H, I>

instead of this

Copy code

typealias Tuple10Of<A, B, C, D, E, F, G, H, I, J> = arrow.Kind10<ForTuple10, A, B, C, D, E, F, G, H, I, J>
typealias Tuple10PartialOf<A, B, C, D, E, F, G, H, I> = arrow.Kind9<ForTuple10, A, B, C, D, E, F, G, H, I>
typealias Tuple10PartialOf2<A, B, C, D, E, F, G, H> = arrow.Kind8<ForTuple10, A, B, C, D, E, F, G, H>
typealias Tuple10PartialOf3<A, B, C, D, E, F, G> = arrow.Kind7<ForTuple10, A, B, C, D, E, F, G>
typealias Tuple10PartialOf4<A, B, C, D, E, F> = arrow.Kind6<ForTuple10, A, B, C, D, E, F>
typealias Tuple10PartialOf5<A, B, C, D, E> = arrow.Kind5<ForTuple10, A, B, C, D, E>
typealias Tuple10PartialOf6<A, B, C, D> = arrow.Kind4<ForTuple10, A, B, C, D>
typealias Tuple10PartialOf7<A, B, C> = arrow.Kind3<ForTuple10, A, B, C>
typealias Tuple10PartialOf8<A, B> = arrow.Kind2<ForTuple10, A, B>
typealias Tuple10PartialOf9<A> = arrow.Kind<ForTuple10, A>

pakoito

07/22/2018, 1:43 AM

Because most typeclasses only provide the last generic parameter, the rest have to be fixed

pakoito

07/22/2018, 1:43 AM

there are a few with 2 parameters, like Bifunctor or ApplicativeError

pakoito

07/22/2018, 1:44 AM

in the case of ApplicativeError, we have the second parameter fixed to Throwable for IO/Deferred/Observable/Flow, and that’s something I plan to fix soon

pakoito

07/22/2018, 1:45 AM

at least for IO, by making it a fully fledged bifunctor

😱 1

pakoito

07/22/2018, 1:47 AM

one example

pakoito

07/22/2018, 1:47 AM

Either.functor()

you have to pass or hint the type of the left side

pakoito

07/22/2018, 1:47 AM

else the compiler complains

pakoito

07/22/2018, 1:48 AM

Either.functor<Throwable>()

pakoito

07/22/2018, 1:48 AM

which is different than

Either.functor<String>()

even if it doesn’t have functions acting on the left side

pakoito

07/22/2018, 1:49 AM

https://github.com/arrow-kt/arrow/blob/master/modules/core/arrow-instances-core/src/main/kotlin/arrow/instances/either.kt#L58-L61

pakoito

07/22/2018, 1:51 AM

see that

Kind<Kind<ForEither, L>, A>

has three possible alias:

Kind2<ForEither, L, A>

Kind<EitherPartialOf<L>, A>

and

EitherOf<L, A>

Eugenio

07/22/2018, 9:15 AM

@pakoito but in that case the left type of either is important, no? If I have an

Either<Throwable, String>

and I apply a

map(String -> Int)

I expect to get back an

Either<Throwable, Int>

Eugenio

07/22/2018, 9:16 AM

You're effectively using the Kinds as a type factory

Eugenio

07/22/2018, 9:17 AM

Which is the whole point of higher kinded generics

Eugenio

07/22/2018, 9:17 AM

And Functor doesn't care about the extra generic type params, it only uses one

Eugenio

07/22/2018, 9:18 AM

So you need to provide a "context" in which those extra params are fixed or inferred

Eugenio

07/22/2018, 9:20 AM

Also, since Either is right-biased, the standard map uses that side, but one can always provide explicit

mapLeft

and

mapRight

that have meaning only for Either

Eugenio

07/22/2018, 11:15 AM

@pakoito another question (unless you want to rest today 😁) : how bad would it be if we changed slightly the way `Kind`s are defined? from:

Copy code

interface Kind<out F, out A>

class ForEither private constructor() { companion object }

@higherkind
sealed class Either<out A, out B> : EitherOf<A, B> {

to:

Copy code

sealed class KindOrId
abstract class KindId(val forType: KClass<out Kind<*, *>>) : KindOrId()
open class Kind<out F: KindOrId, out A> : KindOrId()

object ForEither : KindId(Either::class)

@higherkind
sealed class Either<out A, out B> : EitherOf<A, B>() {

Eugenio

07/22/2018, 11:16 AM

the reason is that right now there isn't a "clear" link from the kind id to the type, at least not one that can easily be resolved from an annotation processor

Eugenio

07/22/2018, 11:17 AM

especially if you take into consideration that someone could create a higher kind without using arrow's processor

Eugenio

07/22/2018, 11:19 AM

it also makes it a tiiiny bit safer to build a higher kind, since you're at least supposed to use the right basic classes instead of anything else

pakoito

07/22/2018, 12:11 PM

out F: KindOrId

-> this doesn’t reflect that F is left-associative