Result.orElse()

class Result<T, E> {
  orElse<R extends Result<unknown, unknown>>(
    f: (e: E) => R
  ): Result<InferOkTypes<R> | T, InferErrTypes<R>>
  
  orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>
}

import { ok, err } from 'neverthrow'

const okVal = ok(12)
const errorCallback = (errVal: string) => 
  err<number, boolean>(true)

okVal.orElse(errorCallback) // Ok(12)
// errorCallback was never called

const errVal = err('BOOOM!')
errVal.orElse((e) => err(true)) // Err(true)

enum DatabaseError {
  PoolExhausted = 'PoolExhausted',
  NotFound = 'NotFound',
}

const dbQueryResult: Result<string, DatabaseError> = 
  err(DatabaseError.NotFound)

const updatedResult = dbQueryResult.orElse((dbError) =>
  dbError === DatabaseError.NotFound
    ? ok('User does not exist')  // Recovery: convert error to success
    : err(500)                    // Convert to different error type
)
// updatedResult is Result<string, number>

function fetchFromPrimaryDb(id: string): Result<User, 'PrimaryDbError'> {
  // ...
}

function fetchFromSecondaryDb(id: string): Result<User, 'SecondaryDbError'> {
  // ...
}

function fetchFromCache(id: string): Result<User, 'CacheError'> {
  // ...
}

const user = fetchFromPrimaryDb('123')
  .orElse(() => fetchFromSecondaryDb('123'))
  .orElse(() => fetchFromCache('123'))
  .orElse(() => ok(getDefaultUser()))
// Tries each source in order until one succeeds

type NetworkError = { code: number; message: string }

function fetchData(): Result<Data, NetworkError> {
  // ... network request
}

const result = fetchData().orElse((error) => {
  // Log the error for monitoring
  console.error('Network error:', error)
  
  // Return cached data as success
  return ok(getCachedData())
})
// result is Result<Data, never> - error is fully handled

type ApiError = 
  | { type: 'NetworkError'; retryable: boolean }
  | { type: 'ValidationError'; field: string }
  | { type: 'AuthError'; reason: string }

function callApi(): Result<Response, ApiError> {
  // ...
}

const result = callApi().orElse((error) => {
  // Only recover from network errors
  if (error.type === 'NetworkError' && error.retryable) {
    return callApi() // Retry
  }
  // Pass other errors through
  return err(error)
})

enum PaymentError {
  InsufficientFunds = 'InsufficientFunds',
  CardDeclined = 'CardDeclined',
  NetworkError = 'NetworkError',
}

function chargeCard(amount: number): Result<Receipt, PaymentError> {
  // ...
}

function chargeSavedCard(amount: number): Result<Receipt, PaymentError> {
  // ...
}

function chargeWallet(amount: number): Result<Receipt, PaymentError> {
  // ...
}

const payment = chargeCard(100)
  .orElse((error) => {
    if (error === PaymentError.CardDeclined) {
      return chargeSavedCard(100)
    }
    return err(error)
  })
  .orElse((error) => {
    if (error === PaymentError.InsufficientFunds) {
      return chargeWallet(100)
    }
    return err(error)
  })

function loadConfig(): Result<Config, 'FileNotFound'> {
  // Try to load from file
}

function getDefaultConfig(): Result<Config, never> {
  return ok({
    port: 3000,
    host: 'localhost',
    // ... default values
  })
}

const config = loadConfig()
  .orElse((error) => {
    console.warn('Config file not found, using defaults')
    return getDefaultConfig()
  })
// config is Result<Config, never> - always succeeds

orElse(f: any): any {
  return f(this.error)
}

orElse(_f: any): any {
  return ok(this.value)
}