From 3c3ad47fc889e4e52c306031cf5f914885efd9d6 Mon Sep 17 00:00:00 2001 From: Jaap Frolich Date: Tue, 13 Jul 2021 12:18:06 +0800 Subject: [PATCH 1/3] add ignorePromise to safely ignore promise --- src/Promise.res | 2 ++ src/Promise.resi | 9 +++++++-- tests/PromiseTest.js | 3 +-- tests/PromiseTest.res | 30 +++++++++++++++--------------- 4 files changed, 25 insertions(+), 19 deletions(-) diff --git a/src/Promise.res b/src/Promise.res index 5d28a30..8697abd 100644 --- a/src/Promise.res +++ b/src/Promise.res @@ -57,3 +57,5 @@ let catch = (promise, callback) => { @bs.scope("Promise") @bs.val external race: array> => t<'a> = "race" + +external ignorePromise: Js.Promise.t<'a> => unit = "%ignore" diff --git a/src/Promise.resi b/src/Promise.resi index 2a6dbdc..2c676ba 100644 --- a/src/Promise.resi +++ b/src/Promise.resi @@ -99,7 +99,7 @@ In case you want to return another promise in your `callback`, consider using \` let catch: (t<'a>, exn => t<'a>) => t<'a> @ocaml.doc(" -`then(promise, callback)` returns a new promise based on the result of `promise`'s value. +`then(promise, callback)` returns a new promise based on the result of `promise`'s value. The `callback` needs to explicitly return a new promise via `resolve`. It is **not allowed** to resolve a nested promise (like `resolve(resolve(1))`). @@ -120,7 +120,7 @@ Promise.resolve(5) external then: (t<'a>, @uncurry ('a => t<'b>)) => t<'b> = "then" @ocaml.doc(" -`thenResolve(promise, callback)` converts an encapsulated value of a promise into another promise wrapped value. +`thenResolve(promise, callback)` converts an encapsulated value of a promise into another promise wrapped value. It is **not allowed** to return a promise within the provided callback (e.g. `thenResolve(value => resolve(value))`). @@ -234,3 +234,8 @@ external all5: ((t<'a>, t<'b>, t<'c>, t<'d>, t<'e>)) => t<('a, 'b, 'c, 'd, 'e)> @bs.scope("Promise") @bs.val external all6: ((t<'a>, t<'b>, t<'c>, t<'d>, t<'e>, t<'f>)) => t<('a, 'b, 'c, 'd, 'e, 'f)> = "all" + +@ocaml.doc(" +`Promise.ignorePromise` is a safe way to ignore a promise. If a value is anything else than a promise, it will raise a type error. +") +external ignorePromise: Js.Promise.t<'a> => unit = "%ignore" diff --git a/tests/PromiseTest.js b/tests/PromiseTest.js index e68e37c..5378e0a 100644 --- a/tests/PromiseTest.js +++ b/tests/PromiseTest.js @@ -343,8 +343,7 @@ function runTests$3(param) { testRaiseErrorThrow(undefined); thenAfterCatch(undefined); testCatchFinally(undefined); - testResolveFinally(undefined); - + return testResolveFinally(undefined); } var Catching = { diff --git a/tests/PromiseTest.res b/tests/PromiseTest.res index 2831f67..b1cddaf 100644 --- a/tests/PromiseTest.res +++ b/tests/PromiseTest.res @@ -17,7 +17,7 @@ module Creation = { Test.run(__POS_OF__("Should resolve test"), str, equal, "test") resolve() }) - ->ignore + ->ignorePromise } let runTests = () => { @@ -55,7 +55,7 @@ module ThenChaining = { Test.run(__POS_OF__("Should be 2"), value, equal, 2) resolve() }) - ->ignore + ->ignorePromise resolve() }) ->catch(e => { @@ -94,7 +94,7 @@ module ThenChaining = { ->thenResolve(num => { num + 1 }) - ->ignore + ->ignorePromise resolve() }) ->catch(e => { @@ -108,10 +108,10 @@ module ThenChaining = { } let runTests = () => { - testThen()->ignore - testInvalidThen()->ignore - testThenResolve()->ignore - testInvalidThenResolve()->ignore + testThen()->Promise.ignorePromise + testInvalidThen()->Promise.ignorePromise + testThenResolve()->Promise.ignorePromise + testInvalidThenResolve()->Promise.ignorePromise } } @@ -249,7 +249,7 @@ module Catching = { Test.run(__POS_OF__("finally should have been called"), wasCalled.contents, equal, true) resolve() }) - ->ignore + ->ignorePromise } let testResolveFinally = () => { @@ -267,16 +267,16 @@ module Catching = { Test.run(__POS_OF__("finally should have been called"), wasCalled.contents, equal, true) resolve() }) - ->ignore + ->ignorePromise } let runTests = () => { - testExternalPromiseThrow()->ignore - testExnThrow()->ignore - testRaiseErrorThrow()->ignore - thenAfterCatch()->ignore - testCatchFinally()->ignore - testResolveFinally()->ignore + testExternalPromiseThrow()->Promise.ignorePromise + testExnThrow()->Promise.ignorePromise + testRaiseErrorThrow()->Promise.ignorePromise + thenAfterCatch()->Promise.ignorePromise + testCatchFinally() + testResolveFinally() } } From ed5c90e9137aab9a3c22a75d749415b52bb55501 Mon Sep 17 00:00:00 2001 From: Jaap Frolich Date: Tue, 20 Jul 2021 08:59:36 +0800 Subject: [PATCH 2/3] ignorePromise => done --- src/Promise.res | 2 +- src/Promise.resi | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/Promise.res b/src/Promise.res index 8697abd..254206d 100644 --- a/src/Promise.res +++ b/src/Promise.res @@ -58,4 +58,4 @@ let catch = (promise, callback) => { @bs.scope("Promise") @bs.val external race: array> => t<'a> = "race" -external ignorePromise: Js.Promise.t<'a> => unit = "%ignore" +external done: Js.Promise.t<'a> => unit = "%ignore" diff --git a/src/Promise.resi b/src/Promise.resi index 2c676ba..2bd5cfa 100644 --- a/src/Promise.resi +++ b/src/Promise.resi @@ -236,6 +236,6 @@ external all5: ((t<'a>, t<'b>, t<'c>, t<'d>, t<'e>)) => t<('a, 'b, 'c, 'd, 'e)> external all6: ((t<'a>, t<'b>, t<'c>, t<'d>, t<'e>, t<'f>)) => t<('a, 'b, 'c, 'd, 'e, 'f)> = "all" @ocaml.doc(" -`Promise.ignorePromise` is a safe way to ignore a promise. If a value is anything else than a promise, it will raise a type error. +`done` is a safe way to ignore a promise. If a value is anything else than a promise, it will raise a type error. ") -external ignorePromise: Js.Promise.t<'a> => unit = "%ignore" +external done: Js.Promise.t<'a> => unit = "%ignore" From d1ebb93981c7af6b78a38891477e2023d6ed07a4 Mon Sep 17 00:00:00 2001 From: Jaap Frolich Date: Tue, 20 Jul 2021 09:01:30 +0800 Subject: [PATCH 3/3] done also in tests --- tests/PromiseTest.res | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/tests/PromiseTest.res b/tests/PromiseTest.res index b1cddaf..01cfcaf 100644 --- a/tests/PromiseTest.res +++ b/tests/PromiseTest.res @@ -17,7 +17,7 @@ module Creation = { Test.run(__POS_OF__("Should resolve test"), str, equal, "test") resolve() }) - ->ignorePromise + ->done } let runTests = () => { @@ -55,7 +55,7 @@ module ThenChaining = { Test.run(__POS_OF__("Should be 2"), value, equal, 2) resolve() }) - ->ignorePromise + ->done resolve() }) ->catch(e => { @@ -94,7 +94,7 @@ module ThenChaining = { ->thenResolve(num => { num + 1 }) - ->ignorePromise + ->done resolve() }) ->catch(e => { @@ -108,10 +108,10 @@ module ThenChaining = { } let runTests = () => { - testThen()->Promise.ignorePromise - testInvalidThen()->Promise.ignorePromise - testThenResolve()->Promise.ignorePromise - testInvalidThenResolve()->Promise.ignorePromise + testThen()->Promise.done + testInvalidThen()->Promise.done + testThenResolve()->Promise.done + testInvalidThenResolve()->Promise.done } } @@ -249,7 +249,7 @@ module Catching = { Test.run(__POS_OF__("finally should have been called"), wasCalled.contents, equal, true) resolve() }) - ->ignorePromise + ->done } let testResolveFinally = () => { @@ -267,14 +267,14 @@ module Catching = { Test.run(__POS_OF__("finally should have been called"), wasCalled.contents, equal, true) resolve() }) - ->ignorePromise + ->done } let runTests = () => { - testExternalPromiseThrow()->Promise.ignorePromise - testExnThrow()->Promise.ignorePromise - testRaiseErrorThrow()->Promise.ignorePromise - thenAfterCatch()->Promise.ignorePromise + testExternalPromiseThrow()->Promise.done + testExnThrow()->Promise.done + testRaiseErrorThrow()->Promise.done + thenAfterCatch()->Promise.done testCatchFinally() testResolveFinally() }