Merge branch 'iliaamiri-concurrent-methods-wrappers'

might-fail · Oct 2, 2024 · 5103d84 · 5103d84
2 parents b4a4133 + b3a5d4a
commit 5103d84
Show file tree

Hide file tree

Showing 31 changed files with 729 additions and 649 deletions.
diff --git a/examples/makeMightFailBasic.ts b/examples/makeMightFailBasic.ts
@@ -1,14 +1,14 @@
-import { makeMightFail } from "../src/makeMightFail";
+import { makeMightFail } from "../src/makeMightFail"
 
-const resolve = (value: { message: string }) => Promise.resolve(value);
+const resolve = (value: { message: string }) => Promise.resolve(value)
 async function main() {
-  const func = makeMightFail(resolve);
-  const { error, result } = await func({ message: "success" });
+  const func = makeMightFail(resolve)
+  const { error, result } = await func({ message: "success" })
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.message);
+  console.log(result.message)
 }
 
-main();
+main()
diff --git a/examples/mightFailBasic.ts b/examples/mightFailBasic.ts
@@ -1,14 +1,12 @@
-import { mightFail } from "../src";
+import { mightFail } from "../src"
 
 async function main() {
-  const { error, result } = await mightFail(
-    Promise.resolve({ message: "success" })
-  );
+  const { error, result } = await mightFail(Promise.resolve({ message: "success" }))
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.message);
+  console.log(result.message)
 }
 
-main();
+main()
diff --git a/examples/mightFailBasicGo.ts b/examples/mightFailBasicGo.ts
@@ -1,14 +1,12 @@
-import { mightFail } from "../src/go";
+import { mightFail } from "../src/go"
 
 async function main() {
-  const [error, result] = await mightFail(
-    Promise.resolve({ message: "success" })
-  );
+  const [error, result] = await mightFail(Promise.resolve({ message: "success" }))
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.message);
+  console.log(result.message)
 }
 
-main();
+main()
diff --git a/examples/mightFailBasicTuple.ts b/examples/mightFailBasicTuple.ts
@@ -1,14 +1,12 @@
-import { mightFail } from "../src/tuple";
+import { mightFail } from "../src/tuple"
 
 async function main() {
-  const [result, error] = await mightFail(
-    Promise.resolve({ message: "success" })
-  );
+  const [result, error] = await mightFail(Promise.resolve({ message: "success" }))
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.message);
+  console.log(result.message)
 }
 
-main();
+main()
diff --git a/examples/mightFailStaticMethods.ts b/examples/mightFailStaticMethods.ts
@@ -1,159 +1,190 @@
-import { mightFail } from "../src";
-import { mightFail as mightFailTuple } from "../src/tuple";
-import { mightFail as mightFailGo } from "../src/go";
+import { mightFail } from "../src"
+import { mightFail as mightFailTuple } from "../src/tuple"
+import { mightFail as mightFailGo } from "../src/go"
 
 async function all() {
   const { error, result } = await mightFail.all([
     Promise.resolve({ message: "success" }),
     Promise.resolve({ message: "success2" }),
-  ]);
+  ])
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.map((r) => r.message));
+  console.log(result.map((r) => r.message))
 }
 
-all();
+all()
+
+async function allDifferentTypes() {
+  const { error, result } = await mightFail.all([Promise.resolve({ message: "success" }), Promise.resolve(5)])
+  if (error) {
+    console.error(error)
+    return
+  }
+  const [res1, res2] = result
+  console.log(res1, res2)
+}
+
+allDifferentTypes()
+
+async function allDestructured() {
+  const { error, result: [result1, result2] = [] } = await mightFail.all([
+    Promise.resolve({ message: "success" }),
+    Promise.resolve(5),
+  ])
+  if (error) {
+    console.error(error)
+    return
+  }
+  console.log(result1, result2)
+}
+
+allDestructured()
 
 async function allSettled() {
   const { error, result } = await mightFail.allSettled([
     Promise.resolve({ message: "success" }),
     Promise.resolve({ message: "success2" }),
-  ]);
+  ])
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.map((r) => r.status));
+  console.log(result.map((r) => r.status))
 }
 
-allSettled();
+allSettled()
 
 async function allTuple() {
   const [error, result] = await mightFailTuple.all([
     Promise.resolve({ message: "success" }),
     Promise.resolve({ message: "success2" }),
-  ]);
+  ])
+  if (error) {
+    console.error(error)
+    return
+  }
+  console.log(result.map((r) => r.message))
+}
+
+allTuple()
+
+async function allTupleDestructured() {
+  const [error, [result1, result2] = []] = await mightFailTuple.all([
+    Promise.resolve({ message: "success" }),
+    Promise.resolve({ message: "success2" }),
+  ])
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.map((r) => r.message));
+  console.log(result1, result2)
 }
 
-allTuple();
+allTupleDestructured()
 
 async function allGo() {
   const [result, error] = await mightFailGo.all([
     Promise.resolve({ message: "success" }),
     Promise.resolve({ message: "success2" }),
-  ]);
+  ])
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.map((r) => r.message));
+  console.log(result.map((r) => r.message))
 }
 
-allGo();
+allGo()
 
 async function returnStringAfter(message: string, time: number) {
-  await new Promise((resolve) => setTimeout(resolve, time));
-  return { message };
+  await new Promise((resolve) => setTimeout(resolve, time))
+  return { message }
 }
 
 async function race() {
-  const { error, result } = await mightFail.race([
-    returnStringAfter("fast", 100),
-    returnStringAfter("slow", 200),
-  ]);
+  const { error, result } = await mightFail.race([returnStringAfter("fast", 100), returnStringAfter("slow", 200)])
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.message);
+  console.log(result.message)
 }
 
-race();
+race()
 
 async function any() {
   const { error, result } = await mightFail.any([
     Promise.reject(new Error("Failure 1")),
     returnStringAfter("success", 100),
     Promise.reject(new Error("Failure 2")),
-  ]);
+  ])
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.message);
+  console.log(result.message)
 }
 
-any();
+any()
 
 async function raceTuple() {
-  const [error, result] = await mightFailTuple.race([
-    returnStringAfter("fast", 100),
-    returnStringAfter("slow", 200),
-  ]);
+  const [error, result] = await mightFailTuple.race([returnStringAfter("fast", 100), returnStringAfter("slow", 200)])
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.message);
+  console.log(result.message)
 }
 
-raceTuple();
+raceTuple()
 
 async function anyTuple() {
   const [error, result] = await mightFailTuple.any([
     Promise.reject(new Error("Failure 1")),
     returnStringAfter("success", 100),
     Promise.reject(new Error("Failure 2")),
-  ]);
+  ])
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.message);
+  console.log(result.message)
 }
 
-anyTuple();
+anyTuple()
 
 async function raceGo() {
-  const [result, error] = await mightFailGo.race([
-    returnStringAfter("fast", 100),
-    returnStringAfter("slow", 200),
-  ]);
+  const [result, error] = await mightFailGo.race([returnStringAfter("fast", 100), returnStringAfter("slow", 200)])
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.message);
+  console.log(result.message)
 }
 
-raceGo();
+raceGo()
 
 async function anyGo() {
   const [result, error] = await mightFailGo.any([
     Promise.reject(new Error("Failure 1")),
     returnStringAfter("success", 100),
     Promise.reject(new Error("Failure 2")),
-  ]);
+  ])
   if (error) {
-    console.error(error);
-    return;
+    console.error(error)
+    return
   }
-  console.log(result.message);
+  console.log(result.message)
 }
 
-anyGo();
+anyGo()
 
 // Call all the new functions
-race();
-any();
-raceTuple();
-anyTuple();
-raceGo();
-anyGo();
+race()
+any()
+raceTuple()
+anyTuple()
+raceGo()
+anyGo()
diff --git a/src/Either.ts b/src/Either.ts
@@ -7,10 +7,10 @@
  */
 export type Either<T> =
   | {
-      error: Error;
-      result: undefined;
+      error: Error
+      result: undefined
     }
   | {
-      result: T;
-      error: undefined;
-    };
+      result: T
+      error: undefined
+    }
diff --git a/src/go/Either.ts b/src/go/Either.ts
@@ -9,4 +9,4 @@
  *
  * @template T The type of the result value.
  */
-export type Either<T> = [undefined, Error] | [T, undefined];
+export type Either<T> = [undefined, Error] | [T, undefined]
diff --git a/src/go/index.ts b/src/go/index.ts
@@ -1,4 +1,4 @@
-  /**
+/**
    * @module
    *
    * This module contains the interface to use the result of mightFail as an error-last tuple.
@@ -15,10 +15,9 @@
 +  * ```
    */
 
+import { type Either } from "./Either"
+import { mightFail, mightFailSync } from "./mightFail"
+import { makeMightFail, makeMightFailSync } from "./makeMightFail"
 
-import { type Either } from "./Either";
-import { mightFail, mightFailSync } from "./mightFail";
-import { makeMightFail, makeMightFailSync } from "./makeMightFail";
-
-export { Either, mightFail, makeMightFail, mightFailSync, makeMightFailSync };
-export default { mightFail, makeMightFail, mightFailSync, makeMightFailSync };
+export { Either, mightFail, makeMightFail, mightFailSync, makeMightFailSync }
+export default { mightFail, makeMightFail, mightFailSync, makeMightFailSync }