feat(std/results): added result async

Author: giveerr

experiments/example/src/index.ts

@@ -1,8 +1,20 @@
 import './definition'
 
+import { Err, err, fromThrowable } from '@sirutils/std/results'
+
+import { exampleTags } from './tag'
 import { $sayHi } from './users/say-hi'
 
 // biome-ignore lint/suspicious/noConsole: Redundant
-console.log($sayHi('yui').unwrap())
+console.log($sayHi('alice').unwrap())
+
+const a = fromThrowable(
+  (path: string, data: string) => Bun.write(path, data),
+  e =>
+    (e instanceof Err
+      ? (e as Err<never, never, never>).appendCause(exampleTags.get('write'))
+      : err(exampleTags.get('write'), 'unexpected').appendCause(exampleTags.get('write'))
+    ).appendData(e)
+)
 
 export * from './tag'

experiments/example/src/tag.ts

@@ -7,3 +7,4 @@ export const exampleTags = Tags.create('experiments/example')
   // causes
   .add('get-user')
   .add('say-hi')
+  .add('write')

packages/std/src/results/index.ts

@@ -5,3 +5,6 @@ export * from './utils/err'
 export * from './utils/fn'
 export * from './utils/try'
 export * from './utils/tag'
+export * from './utils/async'
+
+export * from './tag'

packages/std/src/results/utils/async.ts

@@ -0,0 +1,67 @@
+import type { BlobType } from '../../shared'
+
+import { Err } from './err'
+import { Ok } from './ok'
+
+export class ResultAsync<T, N extends Std.ErrorValues, C extends Std.ErrorValues[] = []>
+  implements PromiseLike<Std.Result<T, N, C>>
+{
+  private _promise: Promise<Std.Result<T, N, C>>
+
+  constructor(res: Promise<Std.Result<T, N, C>>) {
+    this._promise = res
+  }
+
+  // Makes ResultAsync implement PromiseLike<Result>
+  // biome-ignore lint/suspicious/noThenProperty: Redundant
+  then<A, B>(
+    successCallback?: (res: Std.Result<T, N, C>) => A | PromiseLike<A>,
+    failureCallback?: (reason: unknown) => B | PromiseLike<B>
+  ): PromiseLike<A | B> {
+    return this._promise.then(successCallback, failureCallback)
+  }
+
+  async *[Symbol.asyncIterator](): AsyncGenerator<Err<never, N, C>, T> {
+    const result = await this._promise
+
+    if (result.isErr()) {
+      // @ts-expect-error -- This is structurally equivalent and safe
+      yield errAsync(result.error)
+    }
+
+    // @ts-expect-error -- This is structurally equivalent and safe
+    return result.value
+  }
+}
+
+export const okAsync = <T, N extends Std.ErrorValues>(value: T): ResultAsync<T, N, never> =>
+  new ResultAsync(Promise.resolve(new Ok<T, never, never>(value)))
+
+export const errAsync = <N extends Std.ErrorValues>(
+  err: N,
+  message = ''
+): ResultAsync<never, N, never> =>
+  new ResultAsync(Promise.resolve(new Err<never, N, never>(err, message)))
+
+export const fromThrowable = <A extends readonly BlobType[], T, R>(
+  fn: (...args: A) => Promise<T>,
+  errorFn: (err: unknown) => R
+): ((
+  ...args: A
+) => ResultAsync<
+  T,
+  Std.InferNameType<Std.UnionsToResult<R>>,
+  Std.InferCauseType<Std.UnionsToResult<R>>
+>) => {
+  return ((...args: BlobType) => {
+    return new ResultAsync(
+      (async () => {
+        try {
+          return new Ok(await fn(...args))
+        } catch (error) {
+          return errorFn(error) as BlobType
+        }
+      })()
+    )
+  }) as BlobType
+}