refactor(std)!: re-implement result, fix/update option methods (#7)

* refactor(std): re-implement result

* fix(std): fix option methods

* refactor(std): rename result methods, add comments

* feat(std): add ok-or method for option

* fix(std): fix result methods

* fix!: remove index entrypoint

* fix(std): fix circular dependency

* chore(std): add result match

Author: kwaa

packages/std/package.json

@@ -14,10 +14,11 @@
   "bugs": "https://github.com/moeru-ai/std/issues",
   "sideEffects": false,
   "exports": {
-    ".": "./src/index.ts",
     "./async-iterator": "./src/async-iterator/index.ts",
     "./base64": "./src/base64/index.ts",
     "./merge": "./src/merge/index.ts",
+    "./option": "./src/option/index.ts",
+    "./result": "./src/result/index.ts",
     "./set-interval": "./src/set-interval/index.ts",
     "./sleep": "./src/sleep/index.ts",
     "./trampoline": "./src/trampoline/index.ts",
@@ -28,10 +29,6 @@
   ],
   "publishConfig": {
     "exports": {
-      ".": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
       "./async-iterator": {
         "types": "./dist/async-iterator/index.d.ts",
         "default": "./dist/async-iterator/index.js"
@@ -44,6 +41,14 @@
         "types": "./dist/merge/index.d.ts",
         "default": "./dist/merge/index.js"
       },
+      "./option": {
+        "types": "./dist/option/index.d.ts",
+        "default": "./dist/option/index.js"
+      },
+      "./result": {
+        "types": "./dist/result/index.d.ts",
+        "default": "./dist/result/index.js"
+      },
       "./set-interval": {
         "types": "./dist/set-interval/index.d.ts",
         "default": "./dist/set-interval/index.js"
@@ -61,9 +66,7 @@
         "default": "./dist/with-retry/index.js"
       },
       "./package.json": "./package.json"
-    },
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts"
+    }
   },
   "scripts": {
     "build": "pkgroll",

packages/std/scripts/update-exports.ts

@@ -11,33 +11,20 @@ for (let entry of entries) {
 
 const packageJson = JSON.parse(await readFile('./package.json', 'utf8')) as Record<string, unknown>
 
-packageJson.exports = Object.fromEntries([
-  ['.', './src/index.ts'],
-  ...exports.map(e => [`./${e}`, `./src/${e}/index.ts`]),
-])
+packageJson.exports = Object.fromEntries(
+  exports.map(e => [`./${e}`, `./src/${e}/index.ts`]),
+)
 
 packageJson.publishConfig = {
   exports: Object.fromEntries([
-    ['.', {
-      types: './dist/index.d.ts',
-      // eslint-disable-next-line perfectionist/sort-objects
-      default: './dist/index.js',
-    }],
     ...exports.map(e => [`./${e}`, {
       types: `./dist/${e}/index.d.ts`,
       // eslint-disable-next-line perfectionist/sort-objects
       default: `./dist/${e}/index.js`,
     }]),
     ['./package.json', './package.json'],
   ]),
-  main: './dist/index.js',
-  types: './dist/index.d.ts',
 } satisfies Record<string, unknown>
 
 await writeFile('./package.json', `${JSON.stringify(packageJson, null, 2)}\n`)
 console.log('Updated: ./package.json')
-
-const indexTs = exports.map(e => `export * from './${e}'`).join('\n')
-
-await writeFile('./src/index.ts', `${indexTs}\n`)
-console.log('Updated: ./src/index.ts')

packages/std/src/index.ts

@@ -0,0 +1,19 @@
+export interface None {
+  __mo: 'none'
+}
+
+export type Option<T> = None | Some<T>
+
+export interface Some<T> {
+  __mo: 'some'
+  value: T
+}
+
+export const none: Option<never> = {
+  __mo: 'none',
+}
+
+export const some = <T>(value: T): Option<T> => ({
+  __mo: 'some',
+  value,
+})

packages/std/src/option/core.ts

@@ -1,61 +1,2 @@
-export interface None {
-  __mo: 'none'
-}
-
-export type Option<T> = None | Some<T>
-
-export interface Some<T> {
-  __mo: 'some'
-  value: T
-}
-
-export const none: Option<never> = {
-  __mo: 'none',
-}
-
-export const some = <T>(value: T): Option<T> => ({
-  __mo: 'some',
-  value,
-})
-
-export const isSome = <T>(o: Option<T>): o is Some<T> =>
-  o.__mo === 'some'
-
-export const isNone = <T>(o: Option<T>): o is None =>
-  o.__mo === 'none'
-
-export const orElse = <T>(o: Option<T>, fallback: Option<T>): Option<T> =>
-  isSome(o)
-    ? o
-    : fallback
-
-export const andThen = <T1, T2>(o: Option<T1>, onSome: (s: Some<T1>) => T2): Option<T2> =>
-  isSome(o)
-    ? some(onSome(o))
-    : none
-
-export const andThenAsync = async <T1, T2>(o: Option<T1>, onSome: (s: Some<T1>) => Promise<T2>): Promise<Option<T2>> =>
-  isSome(o)
-    ? some(await onSome(o))
-    : o
-
-export const map = <T1, T2>(o: Option<T1>, onSomeValue: (v: T1) => T2): Option<T2> =>
-  isSome(o)
-    ? some(onSomeValue(o.value))
-    : o
-
-export const mapAsync = async <T1, T2>(o: Option<T1>, onSomeValue: (v: T1) => Promise<T2>): Promise<Option<T2>> =>
-  isSome(o)
-    ? some(await onSomeValue(o.value))
-    : o
-
-export const match = <T1, T2>(o: Option<T1>, onSome: (s: Some<T1>) => T2, onNone: () => T2) =>
-  isSome(o)
-    ? onSome(o)
-    : onNone()
-
-/** @experimental */
-export const extract = <T>(o: Option<T>): T | undefined =>
-  isSome(o)
-    ? o.value
-    : undefined
+export * from './core'
+export * from './methods'

packages/std/src/option/index.ts

@@ -0,0 +1,53 @@
+import type { Result } from '../result/core'
+import type { None, Option, Some } from './core'
+
+import { err, ok } from '../result/core'
+import { some } from './core'
+
+export const isSome = <T>(o: Option<T>): o is Some<T> =>
+  o.__mo === 'some'
+
+export const isNone = <T>(o: Option<T>): o is None =>
+  o.__mo === 'none'
+
+export const or = <T>(o: Option<T>, fallback: Option<T>): Option<T> =>
+  isSome(o)
+    ? o
+    : fallback
+
+export const andThen = <T1, T2>(o: Option<T1>, onSome: (s: Some<T1>) => Option<T2>): Option<T2> =>
+  isSome(o)
+    ? onSome(o)
+    : o
+
+// eslint-disable-next-line sonarjs/no-identical-functions
+export const andThenAsync = async <T1, T2>(o: Option<T1>, onSome: (s: Some<T1>) => Promise<Option<T2>>): Promise<Option<T2>> =>
+  isSome(o)
+    ? onSome(o)
+    : o
+
+export const map = <T1, T2>(o: Option<T1>, onSomeValue: (v: T1) => T2): Option<T2> =>
+  isSome(o)
+    ? some(onSomeValue(o.value))
+    : o
+
+export const mapAsync = async <T1, T2>(o: Option<T1>, onSomeValue: (v: T1) => Promise<T2>): Promise<Option<T2>> =>
+  isSome(o)
+    ? some(await onSomeValue(o.value))
+    : o
+
+export const match = <T1, T2>(o: Option<T1>, onSome: (s: Some<T1>) => T2, onNone: () => T2): T2 =>
+  isSome(o)
+    ? onSome(o)
+    : onNone()
+
+export const okOr = <T, E>(o: Option<T>, error: E): Result<T, E> =>
+  isSome(o)
+    ? ok(o.value)
+    : err(error)
+
+/** @experimental */
+export const extract = <T>(o: Option<T>): T | undefined =>
+  isSome(o)
+    ? o.value
+    : undefined

packages/std/src/option/methods.ts

@@ -0,0 +1,21 @@
+export interface Err<E> {
+  __mr: 'err'
+  error: E
+}
+
+export interface Ok<T> {
+  __mr: 'ok'
+  value: T
+}
+
+export type Result<T, E> = Err<E> | Ok<T>
+
+export const err = <T, E>(error: E): Result<T, E> => ({
+  __mr: 'err',
+  error,
+})
+
+export const ok = <T, E>(value: T): Result<T, E> => ({
+  __mr: 'ok',
+  value,
+})

packages/std/src/result/core.ts

@@ -1,66 +1,2 @@
-export interface Result<out T> {
-  orDefault: <U extends T>(defaultValue: U) => T
-  orUndefined: () => T | undefined
-  orElse: <U extends T>(fn: () => U) => T
-  unwrap: () => T
-  unwrapOver: (fn: (error: unknown) => void) => T
-  expect: (message?: string) => T
-  expectOver: (message?: string, fn?: (error: unknown) => void) => T
-  map: <U extends T>(fn: (value: T) => U) => Result<U>
-  mapErr: <U extends T>(fn: (error: unknown) => U) => Result<U>
-}
-
-export const Ok = <T>(value: T): Result<T> => {
-  return {
-    orDefault: () => value,
-    orUndefined: () => value,
-    orElse: fn => fn(),
-    unwrap: () => value,
-    unwrapOver: () => value,
-    expect: () => value,
-    expectOver: () => value,
-    map: (fn) => {
-      try {
-        return Ok(fn(value))
-      }
-      catch (err: unknown) {
-        return Err(err instanceof Error ? err : new Error(String(err)))
-      }
-    },
-    mapErr: <U extends T>(_fn: (error: unknown) => U) => {
-      return Ok(value) as Result<U>
-    },
-  }
-}
-
-export const Err = <T>(error: unknown): Result<T> => {
-  return {
-    orDefault: (defaultValue: T) => defaultValue,
-    orUndefined: () => undefined,
-    orElse: fn => fn(),
-    unwrap: () => {
-      throw error
-    },
-    unwrapOver: (fn) => {
-      fn(error)
-      throw error
-    },
-    expect: (message?: string) => {
-      const newError = new Error(message ?? 'Result is empty')
-      newError.cause = error
-      throw newError
-    },
-    expectOver: (message, fn) => {
-      fn?.(error)
-      const newError = new Error(message ?? 'Result is empty')
-      newError.cause = error
-      throw newError
-    },
-    map: () => {
-      return Err(error)
-    },
-    mapErr: (fn) => {
-      return Err(fn(error))
-    },
-  }
-}
+export * from './core'
+export * from './methods'