A modern programming language that makes developers happier.

kotlinlang

Where has Functor disappeared from Arrow? In 0.12 it was there: <https://arrow-kt.io/docs/0.12/arrow/typeclasses/functor/>

How do I implement a Functor for my own type in 1.1.3?

Hey <@U02EBN3DTKM>,

It was deprecated in 0.12.x, and removed in 0.13.x. Functor (&amp; co) was a abstraction that didn't work well in Kotlin, we tried to look for many solutions and alternatives and we ended removing it in favor of the monadic suspend DSL system we have now.

Not sure if you've been able to take a deep look at it? We introduced the first version in 0.13.x, refining it in 1.x.x and I think we've nailed it for Arrow 2.x.x which we're actively working on now.

Thanks for the info <@U0RM4EPC7>. Can you give me a link to some up-to-date documentation about the monadic suspend DSL system?

Here is the PR with the design document for Arrow 2.x.x, <https://github.com/arrow-kt/arrow/pull/2797>

And in similar fashion how we design _unwrapped monadic DSLs_ for a different monad Resource, also known as Managed. <https://github.com/arrow-kt/arrow/pull/2786>

The current 1.x.x documentation can be found here, <https://arrow-kt.io/docs/apidocs/arrow-core/arrow.core.continuations/-effect/>

Not sure if that solves your current problem, but I'd be happy to take a closer look at your use-case if you could provide some more details or code :slightly_smiling_face:

Thanks a lot! I can provide some details.

I have an interface `Timed&lt;A&gt;`:

&gt; ```interface Timed&lt;A&gt; {
&gt;     fun result(): A
&gt;     fun startMs(): Long
&gt;     fun endMs(): Long
&gt; }```
Now I would like to make `Timed` a Functor so that users could always map overt the result without affecting the timings.

I could just add a function `fun &lt;B&gt; map(fn: (A) -&gt; B): Timed&lt;B&gt;` to my interface but I have the feeling that it is not an optimal solution.

This is mostly oriented around _monadic DSLs_ so that implies `bind` or `flatMap`. Since in Kotlin we don't have a need for `Functor` for collections.

I.e. you can do `list.map { either.bind() }` safely within a DSL to replace _traverse_ :tada:

So in this case I would opt for adding `map`, or I think you would need to define _zip_ or `Applicative` as well and then you can also implement `Monad`.

The problem for _zip_ is how do you combine `startMs` and `endMs` does it take the earliest `startMs` and the latest `endMs` ? :thinking_face:

If these are questions that don't make sense for your use-case I would opt for simply adding the `map` function.

Tip: if you implement it as `inline` you will be able to call `suspend` functions from the lambda, but you'll need to write `map` as an extension function on `Timed&lt;A&gt;` since `inline` functions need to be `final` :wink:

Thanks for the ideas. Yeah, the definition of an Applicative for `Timed&lt;A&gt;` would need some thinking about, but I'm not sure yet whether I need it. I might need a Monad too, but I'll start with a Functor now and see where that takes me.

_zip_ is now `timed { transform(timedA.bind(), timedB.bind(), timedC.bind(), ...) }` and the strategy it applies over combining `startMs` and `endMs` is parameterised.

<https://gist.github.com/nomisRev/e1b5cf39ca4f2931365a1a30f9e0c565>

Wow! You wrote my code for me! Thanks. :smile: :thumbsup: