Typescript函数式编程: 函数异常

翻译自Advanced functional programming in TypeScript: functional exceptions

在看完第一部分和第二部分的Maybe实现后，我们再看一个有用的Monad例子。在这片文章中，我们介绍一个函数式编程中如何解决异常问题。你可以在这里找到源代码。

异常(Exceptions)

异常是代码中处理错误和意料之外情况的常用方式。在Java, C#，当然还有JavasScript等主流语言里都有异常。有趣的是有些语言(比如Rust)特意不引入异常。异常和函数式编程兼容吗？很遗憾，不是很兼容。举个例子，纯函数不应该有副作用。抛出异常其实就是一种副作用 - 导致你程序终止。更糟糕的是异常给代码带来了不可预测性。

function divide(x: number, y: number): number { 
    if (y === 0){
        throw new Error('Cannot divide by zero');
    return x / y;
}

虽然函数签名告诉我们divide返回number, 单并不是说总是会返回number。我们必须非常小心，并记得有一个异常错误要处理。然而，类型系统检查并不能确保我们一定要处理这个异常。

更好的异常

如何显示地说明divide可能出现异常情况？我们来创建一个类 Result<TSuccess, TFailure>。还记得Maybe<T>是不是可以表示Some(某个值)或者None(空值)? 同样，Result<TSuccess, TFailure>表示要么是Success: 正常的执行的流程，要么是Failure: 错误情况(错误用类型TFailure表示)。也就是说，这个新类型的实例要么持有一个有效的结果，要么包含错误结果的相关信息。和异常不一样，现在显示的表达了一个错误可能发生。而且我们也知道了错误的类型(TFailure就是错误类型)。

实现Result

我们从下面的Result定义开始:

export class Result<TSuccess, TFailure> { 
    private constructor(
        private value: TSuccess,
        private errorValue: TFailure
    ) { }

    static success<TSuccess, TFailure>(value: TSuccess) {
        return new Result<TSuccess, TFailure>(value, null);
    }

    static failure(TSuccess, TFailure>(errorValue: TFailure) {
        return new Result<TSuccess, TFailure>(null, errorValue);
    }
}

我们创建了一个类，只有两种方式被实例化 -- 通过success或failure静态方法。
类的内部持有一个value表示成功的结果，或者持有一个errorValue表示错误相关的信息。我们下面写一个简单的方法来获取Result持有的值。记住Result的实例要么是一个Success要么是一个Failure。因此，当获取值得时候我们一定要假设可能是错误的信息。我们需要提供handleError函数来处理错误情况:

get (handleError: (errorValue: TFailure) => TSuccess): TSuccess {
    if (this.value === null){
        return handleError(this.errorValue);
    } else { 
        reutrn this.value;
    }
}

和Maybe类似，我们也需要一些让我们方便使用Result类型的操作。我们先定义map。在正常的情况下，map接受一个函数，并传给这个函数Result持有的值。然而，如果Result包含了一个错误，那么map就忽略传入的函数，直接返回这个错误。

map<R>(f: (wrapped: TSuccess) => R) : Result<R, TFailure> {
    if (this.value === null){
        return Result.failure<R, TFailure>(this.errorValue)
    } else { 
        reutrn Result.success<R, TFailure>(f(this.value);
    }
}

如果我们传入的函数接受Result持有的值单也返回了一个Result! 我们就需要flatMap

flatMap<R>(f: (wrapped: TSuccess)=>Result<R, TFailure>): Result<R, TFailure> {
    if (this.value === null) {
        return Result.failure<R, TFailure>(this.errorValue);
    } else {
        return f(this.value);
    }
}

`Result`实战

棒极了, 我们现在准备好了使用Result这个新的类了。我们改一下之前的代码，现在不用Maybe表示可能为空的值，而是用Result表示可能失败的值。

findById(id: number): Result<Employee, string>{
    const results = this.employees.filter(employee => employee.id ==== id);
    return results.length 
        ? Result.success(results[0])
        : Result.failure("Employee does not exist");
}

我们更新了findById方法。现在如果查找的employee存在, 返回的结果包在了Result.success里面。否则，就返回包含错误相关信息的Result.failure。因此, TFailure在这里是一个string类型。接下来，我们更新一下模型。现在Employee.supervisorId也是一个Result类型。我们没有上级的employee也处理成一种异常情况。

export interface Employee {
    id: number;
    name: string;
    supervisorId: Result<number, string>;
}

private employees: Employee[] = [
    { id: 1, name: "John", supervisorId: Result.failure("No supervisor") },
    { id: 2, name: "Jane", supervisorId: Result.success(1) },
    { id: 3, name: "Joe", supervisorId: Result.success(2) },
];

要使用上面的代码我们要调整一下main.ts文件。首先, 我们修改一下点击事件监听代码，让其根据HTML输入返回一个Result实例。接下来，Result传给getSupervisorName, 这个函数也会返回一个Result结果(我们一会就会看到)。最后，在获取Result里面的值时，我们提供一个回调函数来处理潜在的错误情况。

findEmployeeButtonEl.addEventListener("click", () => {
    const inputResult: Result<string, string> = employeeIdInputEl.value
        ? Result.success(employeeIdInputEl.value)
        : Result.failure("No employee id provided");
    const supervisorNameOrError = getSupervisorName(inputResult)
        .get(error => `Error occured: ${error}`);
    searchResultsEl.innerText = `Supervisor name: ${supervisorNameOrError}`;
});

最后是getSupervisorName函数。这才是最有趣的地方，因为这个函数和之前用Maybe的时候看上去几乎一模一样!

function getSupervisorName(enteredIdResult: Result<string,string>): Result<string,string> {
    return enteredIdResult
        .flatMap(safeParseInt)
        .flatMap(employeeId => repository.findById(employeeId))
        .flatMap(employee => employee.supervisorId)
        .flatMap(supervisorId => repository.findById(supervisorId))
        .map(supervisor => supervisor.name)
}


function safeParseInt(numberString: string): Result<number, string> {
    const result = parseInt(numberString);
    return isNaN(result)
        ? Result.failure("Invalid number format") : Result.success(result);
}

唯一调整的地方是类型签名和safeParseInt函数。事实证明，map和flatMap操作是如此通用，以至于它们可以用相同的代码处理两个不同的场景。希望您现在能看到Monad的力量！现在，您可以运行该程序并享受不错的错误消息。尝试不同的方案，例如提供不存在的ID，没有主管的员工ID，非数字ID等。

总结

在本文中，我们看到了如何使用Monad来用更函数式的方法替换异常。多亏了Result类型，我们可以显示地指出函数可能出现失败情况。更重要的是，我们迫使调用者始终假设某些地方可能出了问题并提供错误处理程序。

此示例中的错误处理已相当简化。我们使用字符串来传达错误消息。但是，没有什么可以阻止你使用更高级的类型来传递更多有意义的信息。例如，您可以使用区分的并集(discriminated unions)来表示不同类型的错误。你有没有觉得比起传统异常处理可读性更强了？