Refine tryit typings

[stefaanv]

PR #131 attemps to

• Improve the typings of the tryit function
• Provide helpers to be able to pass the complete result of the tryit function around without immediately destructing it.

Improve typings

1. With the current implementation, Typescript will indicate the type of the error variable in the below example as Error | undefined while the real type is string

async function throwsAsync(value: number) {
  throw 'something went wrong'
  return value * 2
}

async function test() {
  const [error, result] = await tryit(throwsAsync)(10)
  console.error(error)            // something went wrong
  console.log(typeof error)     // string
}

The new implementation will transform the string into a true Error object.
It is supposed to be "bad smell" to throw anything else than an Error object, this provides a safety net.

2. The new implementation allows to carry the success/failure result around as a more succinct, functional alternative to try/catch blocks. The below will print 15, while it will print Division by zero if the first line of the test() function is changed into const either = add(10, divide(20, 4))

function divide(
  dividend: Either<number> | number,
  divisor: Either<number> | number,
) {
  if (isEither(dividend) && isLeft(dividend)) return dividend
  if (isEither(divisor) && isLeft(divisor)) return divisor
  const dividendValue = isEither(dividend) ? right(dividend) : dividend
  const divisorValue = isEither(divisor) ? right(divisor) : divisor
  if (divisorValue === 0) return createLeft(new Error('Division by zero'))
  return createRight(dividendValue / divisorValue)
}

function add(term1: Either<number> | number, term2: Either<number> | number) {
  if (isEither(term1) && isLeft(term1)) return term1
  if (isEither(term2) && isLeft(term2)) return term2
  const term1Value = isEither(term1) ? right(term1) : term1
  const term2Value = isEither(term2) ? right(term2) : term2
  return createRight(term1Value + term2Value)
}

function test() {
  const either = add(10, divide(20, 4))
  if (isLeft(either)) {
    console.error(left(either).message)
  } else {
    console.log(right(either))
  }
}

Allows to implement a error-handling pipe function

A pipe function can be built (in a next PR) that enhances the chain function with functional error handling i.e. a function that stops executing as soon as one function in the chain return an error - and returns that error.

[aleclarson]

The new implementation will transform the string into a true Error object.

I think this betrays the "principle of least surprise". If I throw a string, it's because I want whoever catches it to receive a string.

 

function test() {
  const either = add(10, divide(20, 4))
  if (isLeft(either)) {
    console.error(left(either).message)
  } else {
    console.log(right(either))
  }
}

An interesting pattern, indeed! Though it feels like you're reimplementing try-catch behavior in a sense (catch then rethrow) when using pass-through checks in add and divide.

A pipe function can be built (in a next PR) that enhances the chain function with functional error handling i.e. a function that stops executing as soon as one function in the chain return an error - and returns that error.

That sounds interesting. Have a few hypothetical examples to look at?