我想创建一个工厂函数，它接受 onOk 和 onErr 处理程序，并返回可能抛出异常的函数包装器。
const mayThrow = (fail: boolean) => {
if (fail) {
throw new Error('failed')
}
return 'ok'
}
让我们定义处理程序及其类型
type Ok<T> = { ok: true, value: T }
type Err<E> = { ok: false, error: E }
type Result<T, E> = Ok<T> | Err<E>
const onOk = <T>(value: T): Ok<T> => ({ ok: true, value })
const onErr = <E>(error: E): Err<E> => ({ ok: false, error })
我有这个工厂函数，我几乎可以正确输入。
function createSafeFactory<
U extends (...args: any[]) => any,
F extends (...args: any[]) => any
>(onOk: U, onErr: F) {
return <A extends any[], T, E>(
fn: (...args: A) => T,
errorFn?: (error: unknown) => E
) => {
return (...args: A): ReturnType<U> | ReturnType<F> => {
try {
const result = fn(...args)
return onOk(result)
} catch (e) {
const error = errorFn ? errorFn(e) : (e as E)
return onErr(error)
}
}
}
}
const safe = createSafeFactory(onOk, onErr)
// const safe: <A extends any[], T, E>(fn: (...args: A) => T, errorFn?: ((error: unknown) => E) | undefined) => (...args: A) => Ok<unknown> | Err<unknown>
const safeFn = safe(mayThrow)
// const safeFn: (fail: boolean) => Ok<unknown> | Err<unknown>
const res = safeFn(true)
// const res: Ok<unknown> | Err<unknown>
if (res.ok) {
const data = res.value
// const data: unknown
}
数据未知而不是
string我想要的是输入的结果
Result<string, never>Ok<string> | Err<never>问题就在这里：
ReturnType<U> | ReturnType<F>UFUFTE我怎样才能实现类似
ReturnType<U<T>> | ReturnType<F<E>>您无法执行任意高阶通用函数类型操作。一般来说，TypeScript 必须放弃并删除泛型类型参数，或者在操作它们之前用它们的约束实例化它们。因此，作用于类型 ReturnType<>
的
<T>(value: T) => Ok<T> 将产生 Ok<unknown>Tunknown在value级别有一些对操作通用函数类型的支持。也就是说，有时您可以编写对泛型函数进行操作并生成不同泛型函数的泛型函数，但您需要实际的 functions 来执行此操作，而不仅仅是它们的类型。 此支持是在 microsoft/TypeScript#30215 中实现的，并且它所支持的内容非常有限。特别是：
当函数调用中的参数表达式属于泛型函数类型时，该函数类型的类型参数将传播到调用的结果类型，如果：
- 被调用的函数是一个泛型函数，它返回具有单个调用签名的函数类型，
- 单个调用签名本身并不引入类型参数，并且
- 在函数调用参数的从左到右处理中，没有对参数表达式的上下文类型中引用的任何类型参数进行推断。
一般来说，您不能用
O extends (arg: any) => anyE extends (arg: any) => anyOAOREA ER。 不幸的是，这还不足以让您的代码开始工作：
function createSafeFactory<OA, OR, EA, ER>(
onOk: (arg: OA) => OR,
onErr: (arg: EA) => ER
) {
return <A extends any[]>(
fn: (...args: A) => OA,
errorFn?: (error: unknown) => EA
) => {
return (...args: A): OR | ER => {
try {
const result = fn(...args)
return onOk(result)
} catch (e) {
const error = errorFn ? errorFn(e) : e as EA //🙃
return onErr(error)
}
}
}
}
const safe = createSafeFactory(onOk, onErr)
/* const safe: <A extends any[]>(
fn: (...args: A) => unknown,
errorFn?: ((error: unknown) => unknown) | undefined
) => (...args: any[]) => Ok<unknown> | Err<unknown> */
（旁白：我不知道为什么您认为可以假设捕获的错误是在没有
onErrerrorFn未能在
safeonOkonErrcreateSafeFactoryA
这里
function createSafeFactory<OA, OR, EA, ER>(
onOk: (arg: OA) => OR,
onErr: (arg: EA) => ER
) {
return (
fn: (...args: any[]) => OA,
errorFn?: (error: unknown) => EA
) => {
return (...args: any[]): OR | ER => {
try {
const result = fn(...args)
return onOk(result)
} catch (e) {
const error = errorFn ? errorFn(e) : e as EA //🙃
return onErr(error)
}
}
}
}
const safe = createSafeFactory(onOk, onErr)
/* const safe: <T, E>(
fn: (...args: any[]) => T,
errorFn?: ((error: unknown) => E) | undefined
) => (...args: any[]) => Ok<T> | Err<E> */
现在在
safeTEfnerrorFn
但是由于const safeFn = safe(mayThrow)
const res = safeFn(true)
// const res: Ok<string> | Err<unknown>
if (res.ok) {
const data = res.value
// const data: string
}
的返回类型忘记了
safeargs
我知道编写与类型类似的代码的唯一方法是 uncurry safeFn("oopsie", 123); // no error, oops
:
createSafeFactory
现在只有一个函数，
function createSafeFn<OA, OR, EA, ER, A extends any[]>(
onOk: (arg: OA) => OR,
onErr: (arg: EA) => ER,
fn: (...args: A) => OA,
errorFn?: (error: unknown) => EA
) {
return (...args: A): OR | ER => {
try {
const result = fn(...args)
return onOk(result)
} catch (e) {
const error = errorFn ? errorFn(e) : (e as EA) //🙃 be true?
return onErr(error)
}
}
}
的返回类型不会引入新的类型参数（
(...args: A): OR | ERAcreateSafeFn
对
const safeFn = createSafeFn(onOk, onErr, mayThrow)
// const safeFn: <E>(fail: boolean) => Err<E> | Ok<string>
的错误调用是错误的：
safeFn
好的通话会产生你想看到的一切。
safeFn("oopsie", 123); // error, yay