separate types

js-fp3/library/result.js

@@ -1,40 +1,15 @@
-/**
- * @template T, E
- * @typedef {Object} Result
- * @property {boolean} isSuccess
- * @property {boolean} isFailure
- * @property {T} [value] - Present when isSuccess is true
- * @property {E} [error] - Present when isFailure is true
- */
-
-/**
- * @template T, E
- * @param {T} value
- * @returns {Result<T, E>}
- */
 export const ok = (value) => ({
   isSuccess: true,
   isFailure: false,
   value,
 });
 
-/**
- * @template T, E
- * @param {E} error
- * @returns {Result<T, E>}
- */
 export const fail = (error) => ({
   isSuccess: false,
   isFailure: true,
   error,
 });
 
-/**
- * @template T, E
- * @param {() => T} f
- * @param {(err: Error) => E} exceptionMapper
- * @returns {Result<T, E>}
- */
 export const catchResult = (f, exceptionMapper) => {
   try {
     return ok(f());
@@ -43,77 +18,32 @@ export const catchResult = (f, exceptionMapper) => {
   }
 };
 
-/**
- * @template TIn, TOut, E
- * @param {(value: TIn) => Result<TOut, E>} binder
- * @returns {(result: Result<TIn, E>) => Result<TOut, E>}
- */
 export const bind = (binder) => (result) =>
   result.isSuccess ? binder(result.value) : fail(result.error);
 
-/**
- * @template TIn, TOut, E
- * @param {(value: TIn) => TOut} mapper
- * @returns {(result: Result<TIn, E>) => Result<TOut, E>}
- */
 export const map = (mapper) => (result) =>
   result.isSuccess ? ok(mapper(result.value)) : fail(result.error);
 
-/**
- * @template T, E
- * @param {(value: T) => void} action
- * @returns {(result: Result<T, E>) => Result<T, E>}
- */
 export const tap = (action) => (result) => {
   if (result.isSuccess) action(result.value);
   return result;
 };
 
-/**
- * @template T, E
- * @param {(error: E) => void} action
- * @returns {(result: Result<T, E>) => Result<T, E>}
- */
 export const tapError = (action) => (result) => {
   if (result.isFailure) action(result.error);
   return result;
 };
 
-/**
- * @template T, EIn, EOut
- * @param {(error: EIn) => EOut} mapper
- * @returns {(result: Result<T, EIn>) => Result<T, EOut>}
- */
 export const mapError = (mapper) => (result) =>
   result.isSuccess ? ok(result.value) : fail(mapper(result.error));
 
-/**
- * @template T, E, TResult
- * @param {(value: T) => TResult} onSuccess
- * @param {(error: E) => TResult} onFailure
- * @returns {(result: Result<T, E>) => TResult}
- */
 export const match = (onSuccess, onFailure) => (result) =>
   result.isSuccess ? onSuccess(result.value) : onFailure(result.error);
 
-/**
- * @template T, E
- * @param {(value: T) => void} onSuccess
- * @param {(error: E) => void} onFailure
- * @returns {(result: Result<T, E>) => void}
- */
 export const switch_ = (onSuccess, onFailure) => (result) => {
   if (result.isSuccess) onSuccess(result.value);
   else onFailure(result.error);
 };
 
-/**
- * Pipe a result through a series of functions (left-to-right composition).
- * This allows chaining without extending the prototype.
- * @template T, E
- * @param {Result<T, E>} result
- * @param {...Function} fns
- * @returns {Result<any, any>}
- */
 export const pipe = (result, ...fns) =>
   fns.reduce((acc, fn) => fn(acc), result);