Result.unwrapOr()

class Result<T, E> {
  unwrapOr<A>(v: A): T | A
}

import { ok, err } from 'neverthrow'

const okVal = ok(12)
const value = okVal.unwrapOr(1)
// value is 12

const errVal = err<number, string>('Oh nooo')
const defaultValue = errVal.unwrapOr(1)
// defaultValue is 1

const myResult = err('Oh noooo')

const multiply = (value: number): number => value * 2

const unwrapped: number = myResult
  .map(multiply)
  .unwrapOr(10)
// unwrapped is 10 (map was skipped because of err)

function divide(a: number, b: number): Result<number, string> {
  if (b === 0) {
    return err('Cannot divide by zero')
  }
  return ok(a / b)
}

const result = divide(10, 2)
  .map((n) => n * 100)
  .unwrapOr(0)
// result is 500

const errorCase = divide(10, 0)
  .map((n) => n * 100)
  .unwrapOr(0)
// errorCase is 0

type User = { name: string; age: number }
type GuestUser = { name: 'Guest'; isGuest: true }

function getUser(id: string): Result<User, string> {
  // ...
}

const user: User | GuestUser = getUser('123').unwrapOr({
  name: 'Guest',
  isGuest: true
})

type Config = {
  port: number
  host: string
  debug: boolean
}

const DEFAULT_CONFIG: Config = {
  port: 3000,
  host: 'localhost',
  debug: false
}

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

const config = loadConfig().unwrapOr(DEFAULT_CONFIG)
// Always get a valid config

function parseNumber(input: string): Result<number, string> {
  const num = parseInt(input, 10)
  return isNaN(num) ? err('Invalid number') : ok(num)
}

const userInput = '42'
const quantity = parseNumber(userInput).unwrapOr(1)
// quantity is 42

const badInput = 'not a number'
const defaultQuantity = parseNumber(badInput).unwrapOr(1)
// defaultQuantity is 1

type ApiResponse = { data: string[]; total: number }

function fetchData(): Result<ApiResponse, Error> {
  // ... API call
}

const emptyResponse: ApiResponse = {
  data: [],
  total: 0
}

const response = fetchData().unwrapOr(emptyResponse)
// Always have a valid response to work with

function getArrayItem<T>(
  arr: T[],
  index: number
): Result<T, string> {
  return index >= 0 && index < arr.length
    ? ok(arr[index])
    : err('Index out of bounds')
}

const items = [10, 20, 30]
const value = getArrayItem(items, 5).unwrapOr(-1)
// value is -1

// These are equivalent:
const result1 = computation().unwrapOr('default')

const result2 = computation().match(
  (value) => value,
  () => 'default'
)
// Same result, but match is more flexible

type User = { id: string; name: string; email: string }

const ANONYMOUS_USER: User = {
  id: '0',
  name: 'Anonymous',
  email: 'anonymous@example.com'
}

function findUserById(id: string): Result<User, DatabaseError> {
  // ... database query
}

const user = findUserById('123').unwrapOr(ANONYMOUS_USER)
// Always have a user object to work with

unwrapOr<A>(_v: A): T | A {
  return this.value
}

unwrapOr<A>(v: A): T | A {
  return v
}