欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

如何利用 Either 和 Option 进行函数式错误处理

程序员文章站 2024-02-17 14:26:10
前言 我将讨论 scala 风格的模式匹配,但首先我需要通过 either 概念建立一些背景知识。either 的其中一个用法是函数式风格的错误处理,我会在本期文章中对其...

前言

我将讨论 scala 风格的模式匹配,但首先我需要通过 either 概念建立一些背景知识。either 的其中一个用法是函数式风格的错误处理,我会在本期文章中对其进行介绍。

在 java 中,错误的处理在传统上由异常以及创建和传播异常的语言支持进行。但是,如果不存在结构化异常处理又如何呢?许多函数式语言不支持异常范式,所以它们必须找到表达错误条件的替代方式。在本文中,我将演示 java 中类型安全的错误处理机制,该机制绕过正常的异常传播机制(并通过 functional java 框架的一些示例协助说明)。

函数式错误处理

如果您想在 java 中不使用异常来处理错误,最根本的障碍是语言的限制,因为方法只能返回单个值。但是,当然,方法可以 返回单个 object(或子类)引用,其中可包含多个值。那么,我可以使用一个 map 来启用多个返回值。请看看清单 1 中的 divide() 方法:

清单 1. 使用 map 处理多个返回值

public static map<string, object> divide(int x, int y) {
map<string, object> result = new hashmap<string, object>();
if (y == 0)
result.put("exception", new exception("div by zero"));
else
result.put("answer", (double) x / y);
return result;
}

在 清单 1 中,我创建了一个 map,以 string 为键,并以 object 为值。在 divide() 方法中,我输出 exception 来表示失败,或者输出 answer 来表示成功。清单 2 中对两种模式都进行了测试:

清单 2. 使用 map 测试成功与失败

@test
public void maps_success() {
map<string, object> result = romannumeralparser.divide(4, 2);
assertequals(2.0, (double) result.get("answer"), 0.1);
}
@test
public void maps_failure() {
map<string, object> result = romannumeralparser.divide(4, 0);
assertequals("div by zero", ((exception) result.get("exception")).getmessage());
}

在 清单 2 中,maps_success 测试验证在返回的 map 中是否存在正确的条目。maps_failure 测试检查异常情况。

这种方法有一些明显的问题。首先,map 中的结果无论如何都不是类型安全的,它禁用了编译器捕获特定错误的能力。键的枚举可以略微改善这种情况,但效果不大。其次,该方法调用器并不知道方法调用是否成功,这加重了调用程序的负担,它要检查可能结果的词典。第三,没有什么能阻止这两个键都有值,这使得结果模棱两可。

我需要的是一种让我能够以类型安全的方式返回两个(或多个)值的机制。

either 类

返回两个不同值的需求经常出现在函数式语言中,用来模拟这种行为的一个常用数据结构是 either 类。在 java 中,我可以使用泛型创建一个简单的 either 类,如清单 3 所示:

清单 3. 通过 either 类返回两个(类型安全的)值

public class either<a,b> {
private a left = null;
private b right = null;
private either(a a,b b) {
left = a;
right = b;
}
public static <a,b> either<a,b> left(a a) {
return new either<a,b>(a,null);
}
public a left() {
return left;
}
public boolean isleft() {
return left != null;
}
public boolean isright() {
return right != null;
}
public b right() {
return right;
}
public static <a,b> either<a,b> right(b b) {
return new either<a,b>(null,b);
}
public void fold(f<a> leftoption, f<b> rightoption) {
if(right == null)
leftoption.f(left);
else
rightoption.f(right);
}
}

在 清单 3中,either 旨在保存一个 left 或 right 值(但从来都不会同时保存这两个值)。该数据结构被称为不相交并集。一些基于 c 的语言包含 union 数据类型,它可以保存含若干种不同类型的一个实例。不相交并集的槽可以保存两种类型,但只保存其中一种类型的一个实例。either 类有一个 private 构造函数,使构造成为静态方法 left(a a) 或 right(b b) 的责任。在类中的其他方法是辅助程序,负责检索和调研类的成员。

利用 either,我可以编写代码来返回异常或 一个合法结果(但从来都不会同时返回两种结果),同时保持类型安全。常见的函数式约定是 either 类的 left 包含异常(如有),而 right 包含结果。

解析罗马数字

我有一个名为 romannumeral 的类(我将其实现​​留给读者去想象)和一个名为 romannumeralparser 的类,该类调用 romannumeral 类。parsenumber() 方法和说明性测试如清单 4 所示:

清单 4. 解析罗马数字

public static either<exception, integer> parsenumber(string s) {
if (! s.matches("[ivxlxcdm]+"))
return either.left(new exception("invalid roman numeral"));
else
return either.right(new romannumeral(s).toint());
}
@test
public void parsing_success() {
either<exception, integer> result = romannumeralparser.parsenumber("xlii");
assertequals(integer.valueof(42), result.right());
}
@test
public void parsing_failure() {
either<exception, integer> result = romannumeralparser.parsenumber("foo");
assertequals(invalid_roman_numeral, result.left().getmessage());
}

在 清单 4 中,parsenumber() 方法执行一个验证(用于显示错误),将错误条件放置在 either 的 left 中,或将结果放在它的 right中。单元测试中显示了这两种情况。

比起到处传递 map,这是一个很大的改进。我保持类型安全(请注意,我可以按自己喜欢使异常尽量具体);在通过泛型的方法声明中,错误是明显的;返回的结果带有一个额外的间接级别,可以解压 either 的结果(是异常还是答案)。额外的间接级别支持惰性。

惰性解析和 functional java

either 类出现在许多函数式算法中,并且在函数式世界中如此之常见,以致 functional java 框架(参阅 参考资料)也包含了一个 either 实现,该实现将在 清单 3 和 清单 4 的示例中使用。但它的目的就是与其他 functional java 构造配合使用。因此,我可以结合使用 either 和 functional java 的 p1 类来创建惰性 错误评估。惰性表达式是一个按需执行的表达式(参阅 参考资料)。

在 functional java 中,p1 类是一个简单的包装器,包括名为 _1() 的方法,该方法不带任何参数。(其他变体:p2 和 p3 等,包含多种方法。)p1 在 functional java 中用于传递一个代码块,而不执行它,使您能够在自己选择的上下文中执行代码。

在 java 中,只要您 throw 一个异常,异常就会被实例化。通过返回一个惰性评估的方法,我可以将异常创建推迟到以后。请看看清单 5 中的示例及相关测试:

清单 5. 使用 functional java 创建一个惰性解析器

public static p1<either<exception, integer>> parsenumberlazy(final string s) {
if (! s.matches("[ivxlxcdm]+"))
return new p1<either<exception, integer>>() {
public either<exception, integer> _1() {
return either.left(new exception("invalid roman numeral"));
}
};
else
return new p1<either<exception, integer>>() {
public either<exception, integer> _1() {
return either.right(new romannumeral(s).toint());
}
};
}
@test
public void parse_lazy() {
p1<either<exception, integer>> result = fjromannumeralparser.parsenumberlazy("xlii");
assertequals((long) 42, (long) result._1().right().value());
}
@test
public void parse_lazy_exception() {
p1<either<exception, integer>> result = fjromannumeralparser.parsenumberlazy("foo");
asserttrue(result._1().isleft());
assertequals(invalid_roman_numeral, result._1().left().value().getmessage());
}

清单 5 中的代码与 清单 4 中的类似,但多了一个 p1 包装器。在 parse_lazy 测试中,我必须通过在结果上调用 _1() 来解压结果,该方法返回 either 的 right,从该返回值中,我可以检索值。在 parse_lazy_exception 测试中,我可以检查是否存在一个 left,并且我可以解压异常,以辨别它的消息。

在您调用 _1() 解压 either 的 left 之前,异常(连同其生成成本昂贵的堆栈跟踪)不会被创建。因此,异常是惰性的,让您推迟异常的构造程序的执行。

提供默认值

惰性不是使用 either 进行错误处理的惟一好处。另一个好处是,您可以提供默认值。请看清单 6 中的代码:

清单 6. 提供合理的默认返回值

public static either<exception, integer> parsenumberdefaults(final string s) {
if (! s.matches("[ivxlxcdm]+"))
return either.left(new exception("invalid roman numeral"));
else {
int number = new romannumeral(s).toint();
return either.right(new romannumeral(number >= max ? max : number).toint());
}
}
@test
public void parse_defaults_normal() {
either<exception, integer> result = fjromannumeralparser.parsenumberdefaults("xlii");
assertequals((long) 42, (long) result.right().value());
}
@test
public void parse_defaults_triggered() {
either<exception, integer> result = fjromannumeralparser.parsenumberdefaults("mm");
assertequals((long) 1000, (long) result.right().value());
}

在 清单 6 中,假设我不接受任何大于 max 的罗马数字,任何企图大于该值的数字都将被默认设置为 max。parsenumberdefaults() 方法确保默认值被放置在 either 的 right 中。

包装异常

我也可以使用 either 来包装异常,将结构化异常处理转换成函数式,如清单 7 所示:

清单 7. 捕获其他人的异常

public static either<exception, integer> divide(int x, int y) {
try {
return either.right(x / y);
} catch (exception e) {
return either.left(e);
}
}
@test
public void catching_other_people_exceptions() {
either<exception, integer> result = fjromannumeralparser.divide(4, 2);
assertequals((long) 2, (long) result.right().value());
either<exception, integer> failure = fjromannumeralparser.divide(4, 0);
assertequals("/ by zero", failure.left().value().getmessage());
}

在 清单 7 中,我尝试除法,这可能引发一个 arithmeticexception。如果发生异常,我将它包装在 either 的 left 中;否则我在 right 中返回结果。使用 either 使您可以将传统的异常(包括检查的异常)转换成更偏向于函数式的风格。

当然,您也可以惰性包装从被调用的方法抛出的异常,如清单 8 所示:

清单 8. 惰性捕获异常

public static p1<either<exception, integer>> dividelazily(final int x, final int y) {
return new p1<either<exception, integer>>() {
public either<exception, integer> _1() {
try {
return either.right(x / y);
} catch (exception e) {
return either.left(e);
}
}
};
}
@test
public void lazily_catching_other_people_exceptions() {
p1<either<exception, integer>> result = fjromannumeralparser.dividelazily(4, 2);
assertequals((long) 2, (long) result._1().right().value());
p1<either<exception, integer>> failure = fjromannumeralparser.dividelazily(4, 0);
assertequals("/ by zero", failure._1().left().value().getmessage());
}

嵌套异常

java 异常有一个不错的特性,它能够将若干种不同的潜在异常类型声明为方法签名的一部分。尽管语法越来越复杂,但 either 也可以做到这一点。例如,如果我需要 romannumeralparser 上的一个方法允许我对两个罗马数字执行除法,但我需要返回两种不同的可能异常情况,那么是解析错误还是除法错误?使用标准的 java 泛型,我可以嵌套异常,如清单 9 所示:

清单 9. 嵌套异常

public static either<numberformatexception, either<arithmeticexception, double>> 
divideroman(final string x, final string y) {
either<exception, integer> possiblex = parsenumber(x);
either<exception, integer> possibley = parsenumber(y);
if (possiblex.isleft() || possibley.isleft())
return either.left(new numberformatexception("invalid parameter"));
int inty = possibley.right().value().intvalue();
either<arithmeticexception, double> errorfory = 
either.left(new arithmeticexception("div by 1"));
if (inty == 1)
return either.right((fj.data.either<arithmeticexception, double>) errorfory);
int intx = possiblex.right().value().intvalue();
either<arithmeticexception, double> result = 
either.right(new double((double) intx) / inty);
return either.right(result);
}
@test
public void test_divide_romans_success() {
fj.data.either<numberformatexception, either<arithmeticexception, double>> result = 
fjromannumeralparser.divideroman("iv", "ii");
assertequals(2.0,result.right().value().right().value().doublevalue(), 0.1);
}
@test
public void test_divide_romans_number_format_error() {
either<numberformatexception, either<arithmeticexception, double>> result = 
fjromannumeralparser.divideroman("ivooo", "ii");
assertequals("invalid parameter", result.left().value().getmessage());
}
@test
public void test_divide_romans_arthmetic_exception() {
either<numberformatexception, either<arithmeticexception, double>> result = 
fjromannumeralparser.divideroman("iv", "i");
assertequals("div by 1", result.right().value().left().value().getmessage());
}

在 清单 9 中,divideroman() 方法首先解压从 清单 4 的原始 parsenumber() 方法返回的 either。如果在这两次数字转换的任一次中发生一个异常,either left 与异常一同返回。接下来,我必须解压实际的整数值,然后执行其他验证标准。罗马数字没有零的概念,所以我制定了一个规则,不允许除数为 1:如果分母是 1,我打包我的异常,并放置在 right 的 left 中。

换句话说,我有三个槽,按类型划分:numberformatexception、arithmeticexception 和 double。第一个 either 的 left 保存潜在的 numberformatexception,它的 right 保存另一个 either。第二个 either 的 left 包含一个潜在的 arithmeticexception,它的 right 包含有效载荷,即结果。因此,为了得到实际的答案,我必须遍历 result.right().value().right().value().doublevalue()!显然,这种方法的实用性迅速瓦解,但它确实提供了一个类型安全的方式,将异常嵌套为类签名的一部分。

option 类

either 是一个方便的概念,在下期文章中,我将使用这个概念构建树形数据结构。scala 中有一个名为 option 的类与之类似,该类在 functional java 中被复制,提供了一个更简单的异常情况:none 表示不合法的值,some 表示成功返回。option 如清单 10 所示:

清单 10. 使用 option

public static option<double> divide(double x, double y) {
if (y == 0)
return option.none();
return option.some(x / y);
}
@test
public void option_test_success() {
option result = fjromannumeralparser.divide(4.0, 2);
assertequals(2.0, (double) result.some(), 0.1);
}
@test
public void option_test_failure() {
option result = fjromannumeralparser.divide(4.0, 0);
assertequals(option.none(), result);
}

如 清单 10 所示,option 包含 none() 或 some(),类似于 either 中的 left 和 right,但特定于可能没有合法返回值的方法。

functional java 中的 either 和 option 都是单体,表示计算 的特殊数据结构,在函数式语言中大量使用。在下一期中,我将探讨有关 either 的单体概念,并在不同的示例中演示它如何支持 scala 风格的模式匹配。

结束语

当您学习一种新范式时,您需要重新考虑所有熟悉的问题解决方式。函数式编程使用不同的习惯用语来报告错误条件,其中大部分可以在 java 中复制,不可否认,也有一些令人费解的语法。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。