type Error<T> = {
  error: T
  value?: never
}

type Success<U> = {
  error?: never
  value: U
}

export type Result<T, U> = NonNullable<Error<T> | Success<U>>

export type UnwrapResult = <T, U>(e: Result<T, U>) => NonNullable<T | U>

export const unwrapResult: UnwrapResult = <T, U>({
  error,
  value,
}: Result<T, U>) => {
  if (value !== undefined && error !== undefined) {
    throw new Error(
      `Received both left and right values at runtime when opening a Result\nSuccess: ${JSON.stringify(
        value,
      )}\nError: ${JSON.stringify(error)}`,
    )
    /*
     We're throwing in this function because this can only occur at runtime if something 
     happens that the TypeScript compiler couldn't anticipate. That means the application
     is in an unexpected state and we should terminate immediately.
    */
  }
  if (error !== undefined) {
    return error as NonNullable<T> // Typescript is getting confused and returning this type as `T | undefined` unless we add the type assertion
  }
  if (value !== undefined) {
    return value as NonNullable<U>
  }
  throw new Error(
    'Received no value or error values at runtime when opening Result',
  )
}

export const isError = <T, U>(e: Result<T, U>): e is Error<T> => {
  return e.error !== undefined
}

export const isSuccess = <T, U>(e: Result<T, U>): e is Success<U> => {
  return e.value !== undefined
}

export const makeError = <T>(value: T): Error<T> => ({ error: value })

export const makeSuccess = <U>(value: U): Success<U> => ({ value: value })