Expose non monadic version of Future

[safareli]

It will be nice to expose non monadic version of Future for which ap would be parallel.
This version could also implement Alternative where alt would be race

[Avaq]

ℹ️ I'm working on this.

[Avaq]

I'm looking into developing this as its own package, extending Fluture with an optional Parallel structure. Some of Flutures core functionality will also be separated out to serve as a base for both packages.

[safareli]

@Avaq why?

So you are planning to have 3 repos like this?:

• Avaq/Fluture-core
• Avaq/Fluture
• Avaq/FluturePar

[Avaq]

why?

In writing a detailed response about my reasons, I realized there may be some issues with this approach (circular dependencies, shared code). I'm going to drop the idea, and keep it in the same package.

[safareli]

After discussing this offline, here is what we came to:

As there is Concurrently in haskell:

newtype Concurrently a = Concurrently { runConcurrently :: IO a }

instance Functor Concurrently where
  fmap f (Concurrently a) = Concurrently $ f <$> a

instance Applicative Concurrently where
  pure = Concurrently . return
  Concurrently fs <*> Concurrently as =
    Concurrently $ (\(f, a) -> f a) <$> concurrently fs as

instance Alternative Concurrently where
  empty = Concurrently $ forever (threadDelay maxBound)
  Concurrently as <|> Concurrently bs =
    Concurrently $ either id id <$> race as bs

We could have something like this:

const mkConcurrently = (TaskRep, concurrently, race, zero) => {
  const Concurrently = daggy.tagged('run')
  Concurrently[fl.zero] = zero
  Concurrently[fl.of] = (a) => Concurrently(TaskRep[fl.of](a))
  Object.assign(Concurrently.prototype, {
    [fl.map](f) {
      return Concurrently(this.run[fl.map](f))
    },
    [fl.ap](a) {
      return Concurrently(concurrently(this.run,a))
    },
    [fl.alt](a) {
      return Concurrently(race(this.run, a))
    },
  })
  return Concurrently
}

Which could be used with any Task/Future/whatever.

Example with Fluture:

const Par  =  mkConcurrently(
  Fluture, 
  (a,b)  => a.par(b),
  (a,b)  => a.race(b),
  Fluture.never
)

Par(Fluture.after(300, 1))[fl.alt](Par(Future.of(2)))
  .run.fork(log, log)

[safareli]

I think using names in spirit of purescript-parallel would be better:

-const Concurrently = daggy.tagged('run')
+const Parallel = daggy.tagged('sequential')

Par(Fluture.after(300, 1))[fl.alt](Par(Future.of(2)))
-  .run.fork(log, log)
+  .sequential.fork(log, log)

[Avaq]

I created https://github.com/fluture-js/concurrify for this purpose. I'm working on the implementation now. Your thoughts?

[safareli]

That's nice!

what you think about moving that to FantasyLand, as fantasy-concurrify for example?

[Avaq]

I'm creating it with the design decisions made for Fluture in mind. I'm not sure if it's too opinionated to host under FantasyLand (eg; the inclusion of @@type). Let's discuss it there: fluture-js/concurrify#1

[Avaq]

The next step, I think, would be to depend on concurrify and expose Future.Par :: Future a b -> ParallelFuture a b and Future.seq :: ParallelFuture a b -> Future a b.