我在锡兰怎么做

Question

我有以下 Java 代码，并希望将其移植到锡兰。

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 语句将无法编译。我将如何在锡兰为此编写测试用例？

Answer 1

@Voiteh on 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 和 or 但函数引用，就像在 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 现在只是一个函数而不是 Condition 可能有办法让它不那么冗长，但我不知道语法”