Using unions for a result about ts-belt HOT 11 OPEN

It looks like that there is no perfect solution - but changing the signature of R.isOk to

declare function isOk<A, unknown >(result: Result<A, unknown>): result is Ok<A>;

Makes it a lot more compatible. Same goes for R.isError

from ts-belt.

I think the fn type should define its result type. In your example, the fn's type signature is function fn(a: number): R.Error<string> | R.Ok<string> | R.Error<{ value: number; message: string; }>, in which the Error type is separated. that's not even possible with rescript code.

let fn = x => {
  switch x {
  | x if Float.isNaN(x) => Error("Number is NaN")
  | x if x > 10. => Ok(x)
  | _ => Error({value: x, message: "Number too small"}) 
  // ^ where error occurs, because the type system inferences 
  // fn's return type as result<float, string> from the first match clause.
  }
}

in rescript, we can fix by describing the custom error type, in this case, a variant represents two cases of the errors.

type myError = JustError(string) | ErrorWithMessage({value: float, message: string})

let fn = (x: float): result<float, myError> => {
  switch x {
  | x if Float.isNaN(x) => Error(JustError("Number is NaN"))
  | x if x > 10. => Ok(x)
  | _ => Error(ErrorWithMessage({value: x, message: "Number too small"}))
  }
}

Maybe some black magic of type-level programming in typescript would handle this, but I think It'll hurt the signatures of functions in the Result module's readability(yes, this change should be applied to all the functions in result module, not just isOk and isError, since the input value, in this case the return type of the fn function is not sanitized).

So I think, in this case you can just write your own error type, not changing signatures of the functions.

type MyError = string | {
	value:number,
	message:string
}

function fn(a: number):R.Result<number,MyError> {
	if (!G.isNumber(a)) return R.Error("Number is NaN")

	return a > 10
		? R.Ok(a)
		: R.Error({ value: a, message: "Number too small" })
}

const x = R.isOk(fn(10)) // => no more errors

from ts-belt.

I'll post a type that meets your request later here, let me know what you think!

from ts-belt.

@JUSTIVE Hey, thank you for the detailed response! :)

For errors this could work, however, within a pipe Ok types are often implicitly defined, and being able to pass to R.isOk a union of R.Ok<string> | R.Ok<something lese> | R.Error to filter out the errors, does seem like a good use case.

But, if this is a ReScript limitation, there also doesnt seem to be a good solution to this ,except manually changing the generated Typescript code, which is not optimal

from ts-belt.

rescript, which is the basis of ts-belt, does not work like this because it uses a stricter type system than typescript. Since typescript is much more flexible than rescript, there seems to be a way if you want to try it. I'm currently working on a trick using hotscript, and I'd like to share it with you as soon as it's completed.

from ts-belt.

Sounds cool, thank you :)

from ts-belt.

just finished making a simple proof-of-concept.
here's link

from ts-belt.