either function for avoiding throwing functions

[meech-ward]

Just an idea for situations where we want to use the same might-fail api, but in cases where throwing makes no sense.

We could have an either function that allows non throwing behaviours:

const doThing = eitherSync(({name}: {name: string}) => {
  if (name === "John") {
    return Error("No John's allowed")
  }
  return {
    name
  }
})

const [error, result] = doThing({name: "John"})

if (!error) {
  console.log(result) // { name: string }
} else {
  console.error(error) // Error
}

• Any value returned from the function, other than an error, would be considered the success value.
• Any returned Errors would be a failure result
• Any Either, Fail, or Might values would just be passed straight through

Here's a basic implementation that would work with synchronous code:

type ExcludeFail<T> = Exclude<T, ReturnType<typeof Fail>>;
type ExcludeError<T> = Exclude<T, ReturnType<typeof Error>>;
export function eitherSync<T extends (...args: any[]) => any>(
  func: T
): (...funcArgs: Parameters<T>) => Either<ExcludeError<ExcludeFail<ReturnType<T>>>> {
  return (...args: Parameters<T>) => {
    const result = func(...args)
    if (result.hasOwnProperty("error") && result.hasOwnProperty("result")) {
      return result
    }
    if (result instanceof Error) {
      return Fail(result)
    }
    return Might(result)
  }
}

Is this a good or bad idea, can it be implemented better?