IO.fromPromise should accept js.Thenable, instead of js.Promise

[japgolly]

js.Thenable is a super-type of js.Promise

[vasilmkd]

I'm not knowledgeable enough to determine if there is a specific reason why only Promise was implemented and not Thenable.

I'm a bit worried by the API docs for Thenable and Promise, particularly about the fact that then is "inherently un-typeable".

This is a genuine question, should we follow the advice of the Promise scaladoc and use these constructs by making a round-trip through Future or would that be too detrimental for performance. I'm just worried about edge cases that would blow these methods up, but are ultimately out of Cats Effect's power to resolve.

Thanks.

[armanbilge]

This is a genuine question, should we follow the advice of the Promise scaladoc and use these constructs by making a round-trip through Future or would that be too detrimental for performance

Here is the toFuture implementation in Scala.js and fromPromise in CE. Maybe I'm missing something, but looks like essentially the same code to me.

    /** Converts the [[Thenable]] into a Scala [[scala.concurrent.Future Future]].
     *
     *  Unlike when calling the `then` methods of [[Thenable]], the resulting
     *  [[scala.concurrent.Future Future]] is always properly typed, and
     *  operations on it will be well-typed in turn.
     */
    def toFuture: Future[A] = {
      val p2 = scala.concurrent.Promise[A]()
      p.`then`[Unit](
          { (v: A) =>
            p2.success(v)
            (): Unit | js.Thenable[Unit]
          },
          js.defined { (e: scala.Any) =>
            p2.failure(e match {
              case th: Throwable => th
              case _             => js.JavaScriptException(e)
            })
            (): Unit | js.Thenable[Unit]
          })
      p2.future
    }
  }

  def fromPromise[A](iop: F[Promise[A]]): F[A] =
    flatMap(iop) { p =>
      async_[A] { cb =>
        val onFulfilled: Function1[A, Unit | Thenable[Unit]] =
          (v: A) => cb(Right(v)): Unit | Thenable[Unit]

        val onRejected: Function1[Any, Unit | Thenable[Unit]] = { (a: Any) =>
          val e = a match {
            case th: Throwable => th
            case _ => JavaScriptException(a)
          }

          cb(Left(e)): Unit | Thenable[Unit]
        }

        p.`then`[Unit](onFulfilled, defined(onRejected))

        ()
      }
    }

[vasilmkd]

No, that's perfect. Thanks.

[armanbilge]

Following revert in #2272, re-opening pending #2273.