Hi I am finally getting around to finishing the `Schedule` d

Question

Hi I am finally getting around to finishing the `Schedule` datatype that will enable users to easily express all sorts of retry repeat strategies and I am at the point of choosing where to add the retry repeat methods Since the whole thing involves delay I was thinking Async or above using `delay` from coroutines but then I saw the `Timer` interface which offers some sort of sleep method for `Concurrent` and some other implementations for rx2 and reactor So the question is where does this go in the typeclass hierarchy

raulraja · Answer

< simon vergauwen> is changing that soon so he may be interested in reading this

simon.vergauwen · Answer

Hey < Jannis> Happy to see you again Some extra info on tyhe typeclasses `Timer` is a separate typeclass because `Async` is not needed for a datatype to `sleep` `Concurrent` can derive `Timer` so all it s syntax is enabled in `Concurrent` typeclass and it has a `timer ` function that returns the derived instance I ll try to take a good look the `Schedule` PR asap and we can discuss further there

Jannis · Answer

Thanks Currently the schedule pr only includes the schedule itself which is merely an effectful function that computes the next delay and whether or not to continue It needs to be implemented on something that can be delayed for the delay returned by the schedule My first guess was monad defer and above but that means using monad defer will get you blocking delay which is almost certainly not what most ppl want

simon.vergauwen · Answer

Nope my initial thought is that you ll need `Timer` + `Monad` which you already have from `MonadDefer`

simon.vergauwen · Answer

I was just wondering a bit about the design I think it can be done a bit simpler with just an ADT which you interpret when you run it with an extension like That s a common approach since you can define any arbitrary pure ADT and interpret it to any `F` using typeclasses That means you can have a more general `Schedule` which is not bounded to `F` ``` fun lt F A gt Kind lt F A gt retry schedule Schedule T Timer lt F gt M Monad lt F gt Kind lt F A gt = fun lt F A gt Kind lt F A gt retry schedule Schedule C Concurrent lt F gt Kind lt F A gt = retry schedule C timer C ```

simon.vergauwen · Answer

Here is an example of a Kotlin library that takes the same approach <https github com 47deg kollect blob master kollect core src main kotlin kollect Kollect kt L137>

simon.vergauwen · Answer

That s how I would approach it but I need to check ZIO again to figure out what operators are needed

Jannis · Answer

The schedule itself needs a monad but that can be any I am a bit worried about type inference when building schedules that is already not so great but I ll see what I can do Implementing retry and repeat should be done over any kind that s a great suggestion thanks I ll add something to the pr tomorrow

simon.vergauwen · Answer

Why does it need Monad

simon.vergauwen · Answer

Is `Schedule` not just a data type that defines how to retry Even if it needs to run any effects to calculate the next retry you could defer that and run that effect within `F` using the typeclasses no

simon.vergauwen · Answer

Or am I missing something

Jannis · Answer

Sorry I missed the notification on this thread

Jannis · Answer

Some combinators need flatMap map just etc iirc So to cacluate the next decision monad might be needed

Jannis · Answer

Combining is the problem because there might be effectful computation embedded that need to be combined hence we need something for F and there is at least one flatMap in there so monad It does not need to be fixed right away if you don t use it however that might hurt type inference

Jannis · Answer

Schedule is best described as a possibly effectful function that produces a decision which describes how to continue if at all and the next state for the schedule

Jannis · Answer

What we could do tho is define everything in schedule over id and generalize it to any monad when someone needs to embed some effect in there which only a few combinators do