如何解决我如何在锡兰做
public interface Condition {
Condition FALSE = facts->false;
Boolean evaluate(Fact<?> fact);
default Condition and(Condition other) {
return fact -> this.evaluate(fact) && other.evaluate(fact);
}
}
@Test void test() {
String str = "A String";
Condition a = fact -> !str.empty();
Condition b = fact -> str.contains("tr");
Condition both = a.and(b);
//expect(both(Fact('fact',str)),true);
}
到目前为止,我已经尝试将alias
用于给定的代码
shared alias Condition => Boolean(Fact<out Anything>);
Condition falseCondition = (Fact<out Anything> fact) => false;
shared interface ConditionComposer {
shared formal Boolean eval(Fact<out Anything> fact);
shared default Condition and(Condition other)<--**I want to pass a Condition here for the below to work** {
return (Fact<out Anything> fact) => this.eval(fact) && other.eval(fact);
}
}
我想将Condition
作为参数传递给and()
,但是由于eval()
是ConditionComposer
的一部分,因此return语句将无法编译。我将如何在锡兰为此编写一个测试用例?
解决方法
@Voiteh在gitter: ceylon/user上提供了给定的解决方案。
shared interface Condition<Fact> {
shared static Condition<Fact> falseCondition => object satisfies Condition<Fact> {
shared actual Boolean evaluate(Fact fact) => false;
};
shared static Condition<Data> create<Data>(Boolean(Data) eval) => object satisfies Condition<Data> {
shared actual Boolean evaluate(Data fact) => eval(fact);
};
shared formal Boolean evaluate(Fact fact);
shared default Condition<Fact> and(Condition<Fact> other) => object satisfies Condition<Fact> {
evaluate(Fact fact) => this.evaluate(fact) && other.evaluate(fact);
};
shared default Condition<Fact> or(Condition<Fact> other) => object satisfies Condition<Fact> {
evaluate(Fact fact) => this.evaluate(fact) || other.evaluate(fact);
};
shared default Condition<Fact> not() => object satisfies Condition<Fact> {
evaluate(Fact fact) => !this.evaluate(fact);
};
}
shared void testConditions() {
value a = Condition.create<String>((String fact) => !fact.empty);
value b = Condition.create<String>((String fact) => fact.contains("str"));
value result = a.and(b).evaluate("A string");
assert (result);
print(result);
}
他进一步建议,“如果您不将条件传递给and和/或函数引用(如create中的条件),则可以将其简化一点:
interface Condition<Fact>{
shared static Condition<Fact> falseCondition => object satisfies Condition<Fact> {
shared actual Boolean evaluate(Fact fact) => false;
};
shared static Condition<Data >create<Data>(Boolean(Data) evala)=> object satisfies Condition<Data>{
shared actual Boolean evaluate(Data fact) => evala(fact);
};
shared formal Boolean evaluate(Fact fact);
shared default Condition<Fact> and(Boolean(Fact) other)=> object satisfies Condition<Fact>{
shared actual Boolean evaluate(Fact fact) => this.evaluate(fact) && other(fact);
};
shared default Condition<Fact> or(Boolean(Fact) other)=> object satisfies Condition<Fact>{
shared actual Boolean evaluate(Fact fact) => this.evaluate(fact) || other(fact);
};
shared default Condition<Fact> not=> object satisfies Condition<Fact>{
shared actual Boolean evaluate(Fact fact) => !this.evaluate(fact);
};
}
shared test void testConditions(){
value a=Condition.create<String>((String fact) => !fact.empty);
value b=((String fact)=> fact.contains("A"));
value result=a.and(b).evaluate("A string");
assert(result);
}
他进一步评论说:“如果b.and(a),第二个选项将不起作用,因为b现在只是一个函数,而不是条件 也许有一种方法可以使它不那么冗长,但我不知道语法”
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。