Functional Java 学习笔记

Functional Java

Functional Java是一个在Java语言中实现函数型编程范式的类库。

从接口上看，该类库似乎与Haskell语言关系密切，接口的方法名很多来自该语言。

<!-- https://mvnrepository.com/artifact/org.functionaljava/functionaljava -->

<dependency>

    <groupId>org.functionaljava</groupId>

    <artifactId>functionaljava</artifactId>

    <version>4.7</version>

</dependency>

Functional Java 与 Java 8

标准的Java 8 也引入了很多函数型编程范式的元素，比如Stream，lambda以及函数型接口。

但在功能上Java 8 远不如Functional Java丰富，使用上也受到一定的限制。

函数接口类型

F0, F, F2, ..., F8

有返回值的函数接口类型。使用该函数接口需要调用接口的 f 方法。

F0没有参数，F有1个参数，F2有2个参数，...，F8有8个参数

F0有1个类型参数，F有2个类型参数，F2有3个类型参数，...，F8有9个类型参数

最后那个类型参数代表返回值类型。

比如 F<Integer, Boolean>的参数类型为Integer,返回值类型为Boolean。

import fj.F;

import fj.F2;

import fj.F3;

F<Integer, Integer> twice = n -> n * 2;

F2<Integer, Integer, Integer> f = (a, b) -> a + b;

F3<Integer, Integer, Integer, Integer> g = (a, b, c) -> a + b + c;

System.out.println(twice.f(6), f.f(6, 7), g.f(3, 4, 5)); // 12 13 12

Effect0, Effect1, Effect2, ..., Effect8

没有返回值的函数接口类型。使用该函数接口需要调用接口的 f 方法。

Effect0没有（类型）参数，Effect1有1个（类型）参数，Effect2有2个（类型）参数，...，Effect8有8个（类型）参数

比如 Effect1<Integer>的参数类型为Integer,返回值类型为void。

import fj.function.Effect1;

Effect1<Integer> abc = n -> System.out.println(n);

abc.f(333);  // 333

Try0, Try1, Try2, ..., Try8

带异常有返回值的函数接口类型。使用该函数接口需要调用接口的 f 方法。

Try0没有参数，Try1有1个参数，Try2有2个参数，...，Try8有8个参数

Try0有2个类型参数，Try1有3个类型参数，Try2有4个类型参数，...，Try8有10个类型参数

最后两个类型参数代表返回值类型和异常类型。

比如 Try1<Integer, Boolean, Exception>的参数类型为Integer,返回值类型为Boolean,异常类型为Exception。

TryEffect0, TryEffect1, TryEffect2, ..., TryEffect8

带异常没有返回值的函数接口类型。使用该函数接口需要调用接口的 f 方法。

TryEffect0没有参数，TryEffect1有1个参数，TryEffect2有2个参数，...，TryEffect8有8个参数

TryEffect0有1个类型参数，TryEffect1有2个类型参数，TryEffect2有3个类型参数，...，TryEffect8有9个类型参数

最后那个类型参数代表异常类型。

比如 TryEffect1<Integer, Exception>的参数类型为Integer,返回值类型为void,异常类型为Exception。

Primitive

提供在基本类型之间进行转换的 F 函数接口的简写形式。

import static fj.data.Array.array;

import static fj.Primitive.Integer_Double;

double d = Integer_Double.f(1);

// d = (double)1;

Double[] ds = array(1, 2, 3).map(Integer_Double).array(Double[].class);

函数接口对照（Functional Java 与 Java 8）

FJ 接口	FJ 方法	Java 8 接口	Java 8 方法
Effect2<T, U>	f	BiConsumer<T, U>	accept
F2<T, U, R>	f	BiFunction<T, U, R>	apply
F2<T, T, T>	f	BinaryOperator<T>	apply
F2<T, U, Boolean>	f	BiPredicate<T, U>	test
F0<Boolean>	f	BooleanSupplier	getAsBoolean

元组类型

P1, P2, ..., P8, P

积（Product）类型（成员类型各异的元组类型）。调用接口的 _1, _2, ..., _8 方法可以读取元组的各个成员。

P1只有1个成员, P2有2个成员, ...，P8内有8个成员。

构建元组需要调用 P 类型的 p 方法以及 p1, p2, ..., p8 方法。

import fj.P;

import fj.P2;

P2<Integer, String> kv = P.p(1, "a");

System.out.println(kv);  // (1,a)

kv = P.<Integer, String>p2().f(2).f("b");

System.out.println(kv);  // (2,b)

V2, ..., V8, V

矢量（Vector）类型（成员类型同一的元组类型）。调用接口的 _1, _2, ..., _8 方法可以读取元组的各个成员。

V2有2个成员, ...，V8内有8个成员。

构建元组需要调用 V 类型的 v 方法以及 v2, ..., v8 方法。

import fj.data.vector.V;

import fj.data.vector.V2;

V2<Integer> kv2 = V.v(1, 3);

System.out.println(kv2.p());  // (1,3)

kv2 = V.<Integer>v2().f(2, 4);

System.out.println(kv2.p());  // (2,4)

数据结构

List

package fp;

import fj.Equal;

import fj.Ord;

import fj.Ordering;

import fj.P;

import fj.data.List;

import fj.data.Option;

import static fj.Equal.intEqual;

import static fj.Ord.intOrd;

import static fj.data.List.list;

public class FJList {

	static void f(Object o) { System.out.println(o); }

	public static void main(String[] args) {

		f(list(1, 1, 1).allEqual(intEqual)); // true

		f(list(1, 2).append(list(3))); // List(1,2,3)

		f(list(1, 2, 3).apply(list(i -> i + 3, i -> i * 2))); // List(4,5,6,2,4,6)

		Integer[] arr = list(1, 2, 3).array(Integer[].class); // 123

		f(List.asString(list('a', 'b', 'c'))); // abc

		f(list(1, 2, 3).bind(i -> list(i, i * 2))); // List(1,2,2,4,3,6)

		f(list(1, 2, 3).bind(list(4, 5, 6), x -> y -> x * y)); // List(4,5,6,8,10,12,12,15,18)

		f(list(1, 2, 3).bind(list(4, 5, 6), (x, y) -> x * y)); // List(4,5,6,8,10,12,12,15,18)

		// takeUntil + dropUntil

		f(list(1, 2, 3).breakk(i -> i % 2 == 0)); // (List(1),List(2,3))

		f(List.cons(3, list(1, 2))); // List(3,1,2)

		f(list(1, 2).cons(3)); // List(3,1,2)

		f(list(1, 2, 3).delete(2, intEqual)); // List(1,3)

		f(list(1, 2, 3, 4, 5).drop(2)); // List(3,4,5)

		f(list(1, 2, 3, 4, 5).dropWhile(i -> i < 3)); // List(3,4,5)

		f(list(1, 2, 3, 4, 5).elementIndex(intEqual, 3)); // Some(2)

		f(list(1, 2, 3, 4, 5).exists(i -> i % 3 == 1)); // true

		f(list(1, 2, 3, 4, 5).filter(i -> i % 2 == 1)); // List(1,3,5)

		f(list(1, 2, 3, 4, 5).find(i -> i / 3 == 1)); // Some(3)

		f(list(1, 2, 3, 4, 5).foldLeft(acc -> i -> acc + i - 1, 0)); // 10

		f(list(1, 2, 3, 4, 5).foldLeft((acc, i) -> acc + i - 1, 0)); // 10

		f(list(1, 2, 3, 4, 5).foldLeft1(acc -> i -> acc + i - 1)); // 11

		f(list(1, 2, 3, 4, 5).foldLeft1((acc, i) -> acc + i - 1)); // 11

		f(list(1, 2, 3, 4, 5).foldRight(acc -> i -> acc + i - 1, 0)); // 10

		f(list(1, 2, 3, 4, 5).foldRight((acc, i) -> acc + i - 1 , 0)); // 10

		f(list(1, 2, 3, 4, 5).forall(i -> i % 2 == 0)); // false

		list(1, 2, 3, 4, 5).foreachDoEffect(i -> System.out.print(i));System.out.println(); // 12345

		f(List.fromString("abcde")); // List(a,b,c,d,e)

		f(list(2, 2, 3, 3).group(Equal.equal(a -> b -> a == b))); // List(List(2,2),List(3,3))

		f(list(1, 2, 3, 4, 5).groupBy(i -> i % 2, intOrd)); // TreeMap((0: List(4,2)),(1: List(5,3,1)))

		f(list(1, 2, 3, 4, 5).groupBy(i -> i % 2, i -> i * 2, Ord.ord(a -> b -> Ordering.fromInt(a - b)))); // TreeMap((0: List(8,4)),(1: List(10,6,2)))

		f(list(1, 2, 3, 4, 5).head()); // 1

		f(list(1, 2, 3, 4, 5).headOption()); // Some(1)

		f(list(1, 2, 3, 4, 5).index(2)); // 3

		f(list(1, 2, 3, 4, 5).init()); // List(1,2,3,4)

		f(list(1, 2, 3, 4, 5).inits()); // List(List(),List(1),List(1,2),List(1,2,3),List(1,2,3,4),List(1,2,3,4,5))

		f(list(1, 2, 3, 4, 5).insertBy(a -> b -> Ordering.fromInt(a - b), 3)); // List(1,2,3,3,4,5)

		f(list(1, 2, 3).intercalate(list(list(9, 9), list(10, 10), list(11, 11)))); // List(9,9,1,2,3,10,10,1,2,3,11,11)

		f(list(1, 2, 3).intersperse(9)); // List(1,9,2,9,3)

		f(list(1, 2, 3).isEmpty()); // false

		f(list(1, 2, 3).isNotEmpty()); // true

		f(list(1, 2, 3).isPrefixOf(intEqual, list(1, 2, 3, 4, 5))); // true

		f(list(1).isSingle()); // true

		f(list(1, 2, 3).isSuffixOf(intEqual, list(0, 1, 2, 3))); // true

		f(List.iterableList(java.util.Arrays.asList(1, 2, 3))); // List(1,2,3)

		f(List.iterateWhile(i -> i + 1, i -> i < 10, 1)); // List(1,2,3,4,5,6,7,8,9)

		f(List.join(list(list(1, 2), list(3, 4)))); // List(1,2,3,4)

		f(list(1, 2, 3).last()); // 3

		f(list(1, 2, 3).length()); // 3

		f(List.<Integer, Integer, Integer>liftM2(a -> b -> a * b).f(list(1, 2, 3)).f(list(1, 2, 3))); // List(1,2,3,2,4,6,3,6,9)

		f(List.lookup(intEqual, list(P.p(1, 2), P.p(3, 4)), 1)); // Some(2)

		f(list(1, 2, 3).map(i -> i * 2)); // List(2,4,6)

		f(list(1, 2, 3).<Integer, Integer>mapM(a -> b -> a * b).f(3)); // List(3,6,9)

		f(list(1, 2, 3).mapMOption(i -> i % 2 == 0 ? Option.some(i / 2) : Option.none())); // None

		f(list(1, 2, 3).mapMOption(i -> i > 0 ? Option.some(i / 2) : Option.none())); // Some(List(1,2,3))

		f(list(1, 2, 3).maximum(intOrd)); // 3

		f(list(1, 2, 3).minimumOption(intOrd)); // Some(1)

		f(list(1, 2, 3).minus(intEqual, list(3, 4, 5))); // List(1,2)

		f(list(1, 2, 2, 2, 3).mode(intOrd)); // 2

		f(List.nil()); // List()

		f(list(1, 2, 2, 3, 3).nub()); // List(1,2,3)

		f(list().orHead(() -> -1)); // -1

		f(list().orTail(() -> list(1, 2))); // List(1,2)

		f(list(1, 2, 3, 4, 5).partition(i -> i % 2 == 0)); // (List(2,4),List(1,3,5))

		f(list(1, 2, 3, 4, 5).partition(3)); // List(List(1,2,3),List(4,5))

		f(List.range(1, 10)); // List(1,2,3,4,5,6,7,8,9)

		f(list(1, 2, 3, 4, 5).removeAll(i -> i % 2 == 0)); // List(1,3,5)

		f(List.replicate(3, 3)); // List(3,3,3)

		f(list(1, 2, 3, 4, 5).reverse()); // List(5,4,3,2,1)

		f(list(1, 2, 3).sequence(list('a', 'b'))); // List(a,b,a,b,a,b)

		f(List.single(3)); // List(3)

		f(list(1, 2, 3).snoc(4)); // List(1,2,3,4)

		f(list(3, 2, 1).sort(intOrd)); // List(1,2,3)

		// takeWhile + dropWhile

		f(list(1, 2, 3, 4, 5).span(i -> i < 3)); // (List(1,2),List(3,4,5))

		f(list(1, 2, 3, 4, 5).splitAt(3)); // (List(1,2,3),List(4,5))

		f(list(1, 2, 3, 4, 5).tail()); // List(2,3,4,5)

		f(list(1, 2, 3, 4, 5).tailOption()); // Some(List(2,3,4,5))

		f(list(1, 2, 3, 4, 5).tails()); // List(List(1,2,3,4,5),List(2,3,4,5),List(3,4,5),List(4,5),List(5),List())

		f(list(1, 2, 3, 4, 5).take(3)); // List(1,2,3)

		f(list(1, 2, 3, 4, 5).takeWhile(i -> i < 3)); // List(1,2)

		f(list(1, 2, 3, 4, 5).toArray()); // Array(1,2,3,4,5)

		f(list(1, 2, 3, 4, 5).toJavaList()); // [1, 2, 3, 4, 5]

		// traverse (\i -> [i, i + 1]) [1, 2, 3]

		f(list(1, 2, 3).traverseList(i -> list(i, i + 1))); // List(List(1,2,3),List(1,2,4),List(1,3,3),List(1,3,4),List(2,2,3),List(2,2,4),List(2,3,3),List(2,3,4))

		f(list(1, 2, 3).traverseOption(i -> i % 2 == 0 ? Option.some(i / 2) : Option.none())); // None

		f(list(2, 4, 6).traverseOption(i -> i % 2 == 0 ? Option.some(i / 2) : Option.none())); // Some(List(1,2,3))

		f(list(1, 2, 3).uncons((a, b) -> b.head(), 0)); // 2

		// unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10

		f(List.unfold(b -> b == 0 ? Option.none() : Option.some(P.p(b, b - 1)), 10)); // List(10,9,8,7,6,5,4,3,2,1)

		f(List.unzip(list(P.p(1, 2), P.p(3, 4)))); // (List(1,3),List(2,4))

		f(list(1, 2, 3).zip(list('a', 'b', 'c'))); // List((1,a),(2,b),(3,c))

		f(list(1, 2, 3).zipIndex()); // List((1,0),(2,1),(3,2))

		f(list(1, 2, 3).zipWith(list(1, 2, 3), a -> b -> a * b)); // List(1,4,9)

		f(list(1, 2, 3).zipWith(list(1, 2, 3), (a, b) -> a * b)); // List(1,4,9)

	}

}

Array

package fp;

import fj.P;

import fj.data.Array;

import static fj.Unit.unit;

import static fj.data.Array.array;

import static fj.data.Array.iterableArray;

public class FJArray {

    static void f(Object o) { System.out.println(o); }

	public static void main(String[] args) {

		f(array(1, 2).append(array(3))); // Array(1,2,3)

		f(array(1, 2, 3).apply(array(i -> i + 3, i -> i * 2))); // Array(4,5,6,2,4,6)

		f(array(new Integer[]{1, 2, 3})); // Array(1,2,3)

		f(array(1, 2, 3).bind(i -> array(i, i * 2))); // Array(1,2,2,4,3,6)

		f(array(1, 2, 3).bind(array(4, 5, 6), x -> y -> x * y)); // Array(4,5,6,8,10,12,12,15,18)

		f(array(1, 2, 3).bind(array(4, 5, 6), (x, y) -> x * y)); // Array(4,5,6,8,10,12,12,15,18)

		f(Array.empty()); // Array()

		f(array(1, 2, 3, 4, 5).exists(i -> i % 3 == 1)); // true

		f(array(1, 2, 3, 4, 5).filter(i -> i % 2 == 1)); // Array(1,3,5)

		f(array(1, 2, 3, 4, 5).find(i -> i / 3 == 1)); // Some(3)

		f(array(1, 2, 3, 4, 5).foldLeft(acc -> i -> acc + i - 1, 0)); // 10

		f(array(1, 2, 3, 4, 5).foldLeft((acc, i) -> acc + i - 1, 0)); // 10

		f(array(1, 2, 3, 4, 5).foldRight(acc -> i -> acc + i - 1, 0)); // 10

		f(array(1, 2, 3, 4, 5).foldRight((acc, i) -> acc + i - 1, 0)); // 10

		f(array(1, 2, 3, 4, 5).forall(i -> i % 2 == 0)); // false

		array(1, 2, 3, 4, 5).foreach(i -> {System.out.print(i); return unit();});System.out.println(); // 12345

		array(1, 2, 3, 4, 5).foreachDoEffect(i -> System.out.print(i));System.out.println(); // 12345

		f(array(1, 2, 3, 4, 5).get(3)); // 4

		f(array(1, 2, 3).isEmpty()); // false

		f(array(1, 2, 3).isNotEmpty()); // true

		f(iterableArray(java.util.Arrays.asList(1, 2, 3))); // Array(1,2,3)

		f(Array.join(array(array(1, 2), array(3, 4)))); // Array(1,2,3,4)

		f(array(1, 2, 3).length()); // 3

		f(array(1, 2, 3).map(i -> i * 2)); // Array(2,4,6)

		f(Array.range(1, 10)); // Array(1,2,3,4,5,6,7,8,9)

		f(array(1, 2, 3, 4, 5).reverse()); // Array(5,4,3,2,1)

		f(array(1, 2, 3, 4, 5).scanLeft(acc -> i -> acc + i - 1, 0)); // Array(0,1,3,6,10)

		f(array(1, 2, 3, 4, 5).scanLeft((acc, i) -> acc + i - 1, 0)); // Array(0,1,3,6,10)

		f(array(1, 2, 3, 4, 5).scanLeft1(acc -> i -> acc + i - 1)); // Array(1,2,4,7,11)

		f(array(1, 2, 3, 4, 5).scanLeft1((acc, i) -> acc + i - 1)); // Array(1,2,4,7,11)

		f(array(1, 2, 3, 4, 5).scanRight(acc -> i -> acc + i - 1, 0)); // Array(10,10,9,7,4)

		f(array(1, 2, 3, 4, 5).scanRight((acc, i) -> acc + i - 1, 0)); // Array(10,10,9,7,4)

		f(array(1, 2, 3, 4, 5).scanRight1(acc -> i -> acc + i - 1)); // Array(11,11,10,8,5)

		f(array(1, 2, 3, 4, 5).scanRight1((acc, i) -> acc + i - 1)); // Array(11,11,10,8,5)

		f(array(1, 2, 3).sequence(array('a', 'b'))); // Array(a,b,a,b,a,b)

		f(Array.single(3)); // Array(3)

		f(Array.unzip(array(P.p(1, 2), P.p(3, 4)))); // (Array(1,3),Array(2,4))

		f(array(1, 2, 3).zip(array('a', 'b', 'c'))); // Array((1,a),(2,b),(3,c))

		f(array(1, 2, 3).zipIndex()); // Array((1,0),(2,1),(3,2))

		f(array(1, 2, 3).zipWith(array(1, 2, 3), a -> b -> a * b)); // Array(1,4,9)

		f(array(1, 2, 3).zipWith(array(1, 2, 3), (a, b) -> a * b)); // Array(1,4,9)

	}

}

Option

package fp;

import fj.data.List;

import fj.data.Option;

import fj.function.Effect1;

import static fj.Unit.unit;

import static fj.data.Option.some;

public class FJOption {

	static void f(Object o) { System.out.println(o); }

	public static void main(String[] args) {

		Effect1<Object> f = o -> System.out.println(o);

		f(some(3).apply(some(i -> i * 2))); // Some(6)

		f(some(3).bind(i -> some(i * 2))); // Some(6)

		f(some(3).bind(some(2), a -> b -> a * b)); // Some(6)

		f(some(3).bindProduct(some('a'))); // Some((3,a))

		f(some(3).exists(i -> i % 2 == 1)); // true

		f(some(2).exists(i -> i % 2 == 1)); // false

		f(Option.<Integer>none().exists(i -> i % 2 == 1)); // false

		f(some(3).filter(i -> i % 2 == 1)); // Some(3)

		f(some(2).filter(i -> i % 2 == 1)); // None

		f(Option.<Integer>none().filter(i -> i % 2 == 1)); // None

		f(some(3).forall(i -> i % 2 == 1)); // true

		f(some(2).forall(i -> i % 2 == 1)); // false

		f(Option.<Integer>none().forall(i -> i % 2 == 1)); // true

		some(3).foreach(i -> {System.out.print(i); return unit();});System.out.println(); // 3

		some(3).foreachDoEffect(i -> System.out.print(i));System.out.println(); // 3

		f(Option.fromNull(1)); // Some(1)

		f(Option.fromString("abc")); // Some(abc)

		f(Option.iif(true, 3)); // Some(3)

		f(Option.iif(false, 3)); // None

		f(Option.iif(i -> i % 2 == 1, 3)); // Some(3)

		f(some(3).isNone()); // false

		f(some(3).isSome()); // true

		f(Option.join(some(some(3)))); // Some(3)

		f(some(3).length()); // 1

		f(Option.<Integer>none().length()); // 0

		f(some(3).liftM2(some(2), (x, y) -> x * y)); // Some(6)

		f(some(3).map(i -> i * 3)); // Some(9)

		f(some(3).orElse(some(0))); // Some(3)

		f(Option.<Integer>none().orElse(some(0))); // Some(0)

		f(Option.<Integer>none().orSome(3)); // 3

		f(Option.sequence(List.list(some(1), some(2), some(3)))); // Some(List(1,2,3))

		f(some(3).sequence(some('a'))); // Some(a)

		f(Option.somes(List.list(some(1), some(2), some(3)))); // List(1,2,3)

		f(some(3).traverseList(i -> List.list(1, 2, 3))); // List(Some(1),Some(2),Some(3))

		f(some(3).traverseOption(i -> i % 2 == 1 ? some(i) : Option.none())); // Some(Some(3))

	}

}

Map

package fp;

import fj.P;

import fj.data.HashMap;

import fj.data.List;

import fj.data.TreeMap;

import static fj.Ord.charOrd;

import static fj.Ord.intOrd;

import static fj.data.HashMap.arrayHashMap;

import static fj.data.TreeMap.treeMap;

public class FJMap {

    static void f(Object o) { System.out.println(o); }

	static void f2(Object o) { System.out.print(o); }

	public static void main(String[] args) {

		{

			HashMap<Integer, Character> m = arrayHashMap(P.p(1, 'a'), P.p(2, 'b')); f(m.toMap()); // {1=a, 2=b}

			m.delete(1); f(m.toMap()); // {2=b}

			m.clear(); f(m.toMap()); // {}

			f(arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).contains(1)); // true

			arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).foreachDoEffect(FJMap::f2); f(""); // (1,a)(2,b)

			f(arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).get(1)); // Some(a)

			m = arrayHashMap(P.p(1, 'a'), P.p(2, 'b')); f2(m.getDelete(1)); f(m.toMap()); // Some(a){2=b}

			f(arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).isEmpty()); // false

			f(arrayHashMap().isEmpty()); // true

			f(arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).keys()); // List(1,2)

			f(arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).map(i -> i + 1, c -> (char)(c + 1)).toMap()); // {2=b, 3=c}

			f(arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).map(kv -> P.p(kv._1() + 1, (char)(kv._2() + 1))).toMap()); // {2=b, 3=c}

			f(arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).mapKeys(i -> i + 1).toMap()); // {2=a, 3=b}

			f(arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).mapValues(c -> (char)(c + 1)).toMap()); // {1=b, 2=c}

			m = arrayHashMap(P.p(1, 'a'), P.p(2, 'b')); m.set(3, 'c'); f(m.toMap()); // {1=a, 2=b, 3=c}

			f(arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).size()); // 2

			f(arrayHashMap().size()); // 0

			f(arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).toArray()); // Array((1,a),(2,b))

			f(arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).toList()); // List((1,a),(2,b))

			f(arrayHashMap(P.p(1, 'a'), P.p(2, 'b')).values()); // List(a,b)

		}

		{

			TreeMap<Integer, Character> m = treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')); f(m.toMutableMap()); // {1=a, 2=b}

			m.delete(1); f(m.toMutableMap()); // {1=a, 2=b}

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).contains(1)); // true

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).get(1)); // Some(a)

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).isEmpty()); // false

			f(treeMap(intOrd).isEmpty()); // true

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).keys()); // List(1,2)

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).map(c -> (char)(c + 1))); // TreeMap((1: b),(2: c))

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).max()); // Some((2,b))

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).minKey()); // Some(1)

			m = treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')); m.set(3, 'c'); f(m.toMutableMap()); // {1=a, 2=b}

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b'), P.p(3, 'c')).split(charOrd, 2)); // (Set(a),Some(b),Set(c))

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b'), P.p(3, 'c')).splitLookup(2)); // (TreeMap((1: a)),Some(b),TreeMap((3: c)))

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).size()); // 2

			f(treeMap(intOrd).size()); // 0

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).toList()); // List((1,a),(2,b))

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).toListReverse()); // List((2,b),(1,a))

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).union(List.list(P.p(3, 'c')))); // TreeMap((1: a),(2: b),(3: c))

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).union(treeMap(intOrd, P.p(3, 'c')))); // TreeMap((1: a),(2: b),(3: c))

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).update(2, c -> (char)(c + 1))); // (true,TreeMap((1: a),(2: c)))

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).update(3, c -> (char)(c + 1), 'z')); // TreeMap((1: a),(2: b),(3: z))

			f(treeMap(intOrd, P.p(1, 'a'), P.p(2, 'b')).values()); // List(a,b)

		}

	}

}

Set

package fp;

import fj.Monoid;

import fj.Ord;

import fj.Ordering;

import fj.data.HashSet;

import fj.data.Set;

import static fj.Ord.intOrd;

import static fj.data.HashSet.hashSet;

import static fj.data.HashSet.iterableHashSet;

import static fj.data.Set.iterableSet;

import static fj.data.Set.set;

public class FJSet {

	static void f(Object o) { System.out.println(o); }

	static void f2(Object o) { System.out.println(o); }

	public static void main(String[] args) {

		{

			Set<Integer> s = set(intOrd, 1, 2); f(s.toJavaSet()); // [1, 2]

			f(s.bind(intOrd, a -> set(intOrd, a, a * 2))); // Set(1,2,4)

			f(s.delete(1)); // true

			f(s.size()); // 1

			f(Set.empty(intOrd).toJavaSet()); // []

            f(set(intOrd, 1, 2, 3, 4).filter(a -> a % 2 == 0)); // Set(2,4)

            f(set(intOrd, 1, 2, 3, 4).foldMap(a -> a, Monoid.intAdditionMonoid)); // 10

            f(set(intOrd, 1, 2, 3, 4).foldMapRight(a -> a, Monoid.intAdditionMonoid)); // 10

            f(set(intOrd, 1, 2).insert(3).toJavaHashSet()); // [1, 2, 3]

            f(set(intOrd, 1, 2, 3).intersect(set(intOrd, 3, 4, 5))); // Set(3)

            f(set(intOrd).isEmpty()); // true

			f(iterableSet(intOrd, java.util.Arrays.asList(1, 2, 3))); // Set(1,2,3)

            f(Set.join(intOrd, set(Ord.ord(a -> b -> Ordering.fromInt(a.size() - b.size())), set(intOrd, 1, 2, 3), set(intOrd, 3, 4, 5)))); // Set(3,4,5)

            f(set(intOrd, 1, 2, 3, 4).lookup(3)); // Some(3)

            f(set(intOrd, 1, 2, 3, 4).lookupGE(3)); // Some(3)

            f(set(intOrd, 1, 2, 3, 4).lookupGT(3)); // Some(4)

            f(set(intOrd, 1, 2, 3, 4).lookupLE(3)); // Some(3)

            f(set(intOrd, 1, 2, 3, 4).lookupLT(3)); // Some(2)

            f(set(intOrd, 1, 2, 3).map(intOrd, a -> a + 1)); // Set(2,3,4)

            f(set(intOrd, 1, 2, 3).max());

            f(set(intOrd, 1, 2, 3).member(3));

            f(set(intOrd, 1, 2, 3).minus(set(intOrd, 3, 4, 5)));

			f(set(intOrd, 1, 2).isEmpty()); // false

            f(Set.single(intOrd, 3)); // Set(3)

            f(set(intOrd, 1, 2, 3).size()); // 3

            f(set(intOrd, 1, 2, 3).split(2)); // (Set(1),Some(2),Set(3))

            f(set(intOrd, 1, 2).subsetOf(set(intOrd, 1, 2, 3))); // true

            f(set(intOrd, 1, 2).toList()); // List(1,2)

            f(set(intOrd, 1, 2).toListReverse()); // List(2,1)

            f(set(intOrd, 1, 2).toStreamReverse().toList()); // List(2,1)

            f(set(intOrd, 1, 2, 3).union(set(intOrd, 3, 4, 5))); // Set(1,2,3,4,5)

            f(set(intOrd, 1, 2, 3).update(2, a -> a + 1)); // (true,Set(1,3))

		}

		{

			HashSet<Integer> s = hashSet(1, 2); f(s.toJavaSet()); // [1, 2]

			f(s.contains(1)); // true

			f(s.delete(1)); // true

			s.clear(); f(s.toJavaSet()); // []

			f(iterableHashSet(java.util.Arrays.asList(1, 2, 3)).toJavaSet()); // [1, 2, 3]

			s.set(3); f(s.toJavaSet()); // [3]

			f(s.size()); // 1

			f(HashSet.empty().toJavaSet()); // []

			f(hashSet(1, 2).isEmpty()); // false

			f(hashSet().isEmpty()); // true

			f(hashSet(1, 2).toList()); // List(1,2)

		}

	}

}

Seq

package fp;

import fj.data.Seq;

import static fj.data.Seq.seq;

public class FJSeq {

	static void f(Object o) { System.out.println(o); }

	public static void main(String[] args) {

		f(seq(1, 2).append(seq(3))); // Seq(1,2,3)

		f(seq(1, 2).cons(3)); // Seq(3,1,2)

		f(seq(1, 2, 3, 4, 5).delete(2)); // Seq(1,2,4,5)

		f(seq(1, 2, 3, 4, 5).drop(2)); // Seq(3,4,5)

		f(Seq.empty()); // Seq()

		f(seq(1, 2, 3, 4, 5).filter(i -> i % 2 == 1)); // Seq(1,3,5)

		f(seq(1, 2, 3, 4, 5).foldLeft((acc, i) -> acc + i - 1, 0)); // 10

		f(seq(1, 2, 3, 4, 5).foldRight((acc, i) -> acc + i - 1, 0)); // 10

		f(seq(1, 2, 3, 4, 5).head()); // 1

		f(seq(1, 2, 3, 4, 5).headOption()); // Some(1)

		f(seq(1, 2, 3, 4, 5).index(2)); // 3

		f(seq(1, 2, 3, 4, 5).init()); // Seq(1,2,3,4)

		f(seq(1, 2, 3, 4, 5).insert(3, 6)); // Seq(1,2,3,6,4,5)

		f(seq(1, 2, 3).isEmpty()); // false

		f(seq(1, 2, 3).isNotEmpty()); // true

		f(seq(1, 2, 3, 4, 5).last()); // 5

		f(seq(1, 2, 3, 4, 5).length()); // 5

		f(seq(1, 2, 3).map(i -> i * 2)); // Seq(2,4,6)

		f(Seq.single(3)); // Seq(3)

		f(seq(1, 2, 3).snoc(4)); // Seq(1,2,3,4)

		f(seq(1, 2, 3).split(1)); // (Seq(1),Seq(2,3))

		f(seq(1, 2, 3, 4, 5).tail()); // Seq(2,3,4,5)

		f(seq(1, 2, 3, 4, 5).take(3)); // Seq(1,2,3)

		f(seq(1, 2, 3, 4, 5).toList()); // List(1,2,3,4,5)

		f(seq(1, 2, 3, 4, 5).toJavaList()); // [1, 2, 3, 4, 5]

		f(seq(1, 2, 3, 4, 5).update(2, 6)); // Seq(1,2,6,4,5)

	}

}

巴特西