Changelog

import { parseUserInput } from 'imaginary-parser'
import { logParseError } from 'imaginary-logger'
import { insertUser } from 'imaginary-database'

const resAsync = parseUserInput(userInput)
  .orTee(logParseError)  // Log errors without affecting the Result
  .asyncAndThen(insertUser)

// Note: No LogError appears in the Result type

// Now valid:
const result: Result<void, never> = ok()
const error: Result<never, void> = err()
const asyncResult: ResultAsync<void, never> = okAsync()
const asyncError: ResultAsync<never, void> = errAsync()

function myFunc(): Result<number, string> {
  return safeTry<number, string>(function*() {
    const value = yield* mayFail().safeUnwrap()  // Had to call safeUnwrap
    return ok(value * 2)
  })
}

function myFunc(): ResultAsync<number, string> {
  return safeTry<number, string>(function*() {
    const value = yield* mayFail()  // No safeUnwrap needed
    return ok(value * 2)
  })
}

- result.orElse<ErrType>(foo)
+ result.orElse<OkType, ErrType>(foo)

// Now you can chain directly
safeTry(async function* () {
  // ...
})
  .map(x => x * 2)
  .andThen(processValue)
  .match(
    (value) => console.log(value),
    (error) => console.error(error)
  )

// andTee for logging (errors ignored)
parseUserInput(userInput)
  .andTee(logUser)
  .asyncAndThen(insertUser)

// andThrough for validation (errors propagated)
parseUserInput(userInput)
  .andThrough(validateUser)
  .asyncAndThen(insertUser)

// Error type is inferred as 'NotFound' (not generic string)
const notFound = err('NotFound')

// Useful for pattern matching
if (result.isErr()) {
  switch (result.error) {
    case 'NotFound':
      return 404
    case 'Unauthorized':
      return 401
    default:
      return 500
  }
}