函数式Java将arity-2函数（F2）绑定到选项

我了解功能性java选项的基本绑定语法

Option.some(2).bind(new F<Integer,Option<Integer>>(){
    public Option<Integer>f(Integer i){
        return Option.some(i/2);
    }
};

Option.some（2）.bind（新的F（）{
公共选项f（整数i）{
返回选项。部分（i/2）；
}
};

这对单输入函数很有效，但我不知道如何使用多输入函数（如F2、F3等）

即：

newf2（）{
公共选项F（整数a、整数b）{
返回选项。部分（a/b）；
}
} 

我知道我遗漏了一些东西，但文档有点稀疏。

---

想法？

我不知道你在问什么，但是如果你试图将一个二元函数绑定到

选项中，你应该在绑定它之前部分应用二元函数。因此，这将导致一个具有固定第一个参数的一元函数：

(new F2<...>{ ... }).f(5)

（新F2{…}）.f（5）

（将第一个参数绑定到
5
，返回一个新的一元函数）

我已经搜索了第二个参数，但没有找到一个局部涂抹器。这很奇怪。
突破

诀窍是您需要取消arity函数的rry，并将其绑定到选项的乘积

例如：

arity-5实现

import fj.F;
import fj.F5;
import fj.P5;

public abstract class F5Optional<At, Bt, Ct, Dt, Et, Ft> extends F5<At, Bt, Ct, Dt, Et, Ft> {

    public final F<P5<At, Bt, Ct, Dt, Et>, Ft> tupleize() {
        return new F<P5<At, Bt, Ct, Dt, Et>, Ft>() {

            @Override
            public Ft f(final P5<At, Bt, Ct, Dt, Et> p) {
                return F5Optional.this.f(p._1(), p._2(), p._3(), p._4(), p._5());
            }
        };
    }

}

导入fj.F；
导入fj.F5；
进口fj.P5；
公共抽象类F5可选扩展F5{
公共最终F tupleize（）{
返回新的F（）{
@凌驾
公共金融时报f（最终P5 p）{
返回F5Optional.this.f（p._1（），p._2（），p._3（），p._4（），p._5（））；
}
};
}
}

用法：

    F5Optional<Integer, Integer, Integer, Integer, Integer, Option<Integer>> f5 = new F5Optional<Integer, Integer, Integer, Integer, Integer, Option<Integer>>() {

        @Override
        public Option<Integer> f(Integer a, Integer b, Integer c, Integer d, Integer e) {
            return Option.some(a + b + c + d + e);
        }
    };
    Option<Integer> test2 = b.bindProduct(Option.some(1), Option.some(1), Option.some(1), Option.some(1)).bind(f5.tupleize());
    Assert.assertTrue(new Integer(8).equals(test2.toNull()));

    Option<Integer> nullInteger = Option.none();
    Option<Integer> test3 = b.bindProduct(nullInteger, Option.some(1), Option.some(1), Option.some(1)).bind(f5.tupleize());
    Assert.assertTrue(test3.isNone());

F5Optional f5=new F5Optional（）{
@凌驾
公共选项f（整数a、整数b、整数c、整数d、整数e）{
返回选项。部分（a+b+c+d+e）；
}
};
Option test2=b.bindProduct（Option.some（1），Option.some（1），Option.some（1），Option.some（1））.bind（f5.tupleize（））；
Assert.assertTrue（新的整数（8）.equals（test2.toNull（））；
Option nullInteger=Option.none（）；
Option test3=b.bindProduct（null整数，Option.some（1），Option.some（1），Option.some（1））.bind（f5.tupleize（））；
Assert.assertTrue（test3.isNone（））；
您的解决方案可以工作，使用一个元组（单参数）而不是两个参数并使用它们。
另一种可能更好的方法是（我支持Diego）使用部分函数和curry。
例如，您可以执行以下操作：

public final F2<Integer, Integer, Option<Integer>> sumInteger() {
    return new F2<Integer,Integer,Option<Integer>>() {
        @Override
        public Option<Integer> f(Integer a, Integer b) {
            /* you logic here */
        }
    }; 
}

public final F<Integer, Option<Integer>> partialSumInteger(final F2<Integer, Integer, Option<Integer>> f2, final Integer fixed) {
    return Function.partialApply2(f2.curry(), fixed);
}

public final F2 sumInteger（）{
返回新的F2（）{
@凌驾
公共选项f（整数a、整数b）{
/*你有逻辑吗*/
}
}; 
}
公共最终F部分整数（最终F2，最终整数固定）{
返回函数.partialApply2（f2.curry（），已修复）；
}

然后将您现在的1-arity函数传递给bind。看看Functional Java的类
fj.function
，它包含用于转换和部分应用n-arity函数的函数。我同意文档不是最好的。
在真正的函数式编程语言中，您可以使用
flip f b a=f a b
来实现这一点<代码>翻转myfunc b

public final F2<Integer, Integer, Option<Integer>> sumInteger() {
    return new F2<Integer,Integer,Option<Integer>>() {
        @Override
        public Option<Integer> f(Integer a, Integer b) {
            /* you logic here */
        }
    }; 
}

public final F<Integer, Option<Integer>> partialSumInteger(final F2<Integer, Integer, Option<Integer>> f2, final Integer fixed) {
    return Function.partialApply2(f2.curry(), fixed);
}