Package org.optaplanner.core.api.score.stream

## Class ConstraintCollectors

- java.lang.Object
- - org.optaplanner.core.api.score.stream.ConstraintCollectors

-     public final class ConstraintCollectors
      extends Object

  Creates an `UniConstraintCollector`, `BiConstraintCollector`, ... instance for use in `UniConstraintStream.groupBy(Function, UniConstraintCollector)`, ...

- - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <A> UniConstraintCollector<A,​?,​Integer>` | `count()` |
    `static <A,​B> BiConstraintCollector<A,​B,​?,​Integer>` | `countBi()` |
    `static <A> UniConstraintCollector<A,​?,​Integer>` | `countDistinct()` |
    `static <A,​B> BiConstraintCollector<A,​B,​?,​Integer>` | `countDistinct​(BiFunction<A,​B,​?> groupValueMapping)` |
    `static <A> UniConstraintCollector<A,​?,​Integer>` | `countDistinct​(Function<A,​?> groupValueMapping)` |
    `static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Integer>` | `countDistinct​(QuadFunction<A,​B,​C,​D,​?> groupValueMapping)` |
    `static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Integer>` | `countDistinct​(TriFunction<A,​B,​C,​?> groupValueMapping)` |
    `static <A,​B> BiConstraintCollector<A,​B,​?,​Long>` | `countDistinctLong​(BiFunction<A,​B,​?> groupValueMapping)` |
    `static <A> UniConstraintCollector<A,​?,​Long>` | `countDistinctLong​(Function<A,​?> groupValueMapping)` |
    `static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Long>` | `countDistinctLong​(QuadFunction<A,​B,​C,​D,​?> groupValueMapping)` |
    `static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Long>` | `countDistinctLong​(TriFunction<A,​B,​C,​?> groupValueMapping)` |
    `static <A> UniConstraintCollector<A,​?,​Long>` | `countLong()` |
    `static <A,​B> BiConstraintCollector<A,​B,​?,​Long>` | `countLongBi()` |
    `static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Long>` | `countLongQuad()` |
    `static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Long>` | `countLongTri()` |
    `static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Integer>` | `countQuad()` |
    `static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Integer>` | `countTri()` |
    `static <A extends Comparable<A>> UniConstraintCollector<A,​?,​A>` | `max()` | Returns a collector that finds a maximum value in a group of `Comparable` elements.
    `static <A> UniConstraintCollector<A,​?,​A>` | `max​(Comparator<A> comparator)` | As defined by `max()`, only with a custom `Comparator`.
    `static <A,​B,​Mapped extends Comparable<Mapped>> BiConstraintCollector<A,​B,​?,​Mapped>` | `max​(BiFunction<A,​B,​Mapped> groupValueMapping)` | As defined by `max(Function)`.
    `static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​Mapped>` | `max​(BiFunction<A,​B,​Mapped> groupValueMapping, Comparator<Mapped> comparator)` | As defined by `max(Function)`, only with a custom `Comparator`.
    `static <A,​Mapped extends Comparable<Mapped>> UniConstraintCollector<A,​?,​Mapped>` | `max​(Function<A,​Mapped> groupValueMapping)` | Returns a collector that finds a maximum value in a group of `Comparable` elements.
    `static <A,​Mapped> UniConstraintCollector<A,​?,​Mapped>` | `max​(Function<A,​Mapped> groupValueMapping, Comparator<Mapped> comparator)` | As defined by `max(Function)`, only with a custom `Comparator`.
    `static <A,​B,​C,​D,​Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped>` | `max​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)` | As defined by `max(Function)`.
    `static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped>` | `max​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping, Comparator<Mapped> comparator)` | As defined by `max(Function)`, only with a custom `Comparator`.
    `static <A,​B,​C,​Mapped extends Comparable<Mapped>> TriConstraintCollector<A,​B,​C,​?,​Mapped>` | `max​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)` | As defined by `max(Function)`.
    `static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​Mapped>` | `max​(TriFunction<A,​B,​C,​Mapped> groupValueMapping, Comparator<Mapped> comparator)` | As defined by `max(Function)`, only with a custom `Comparator`.
    `static <A extends Comparable<A>> UniConstraintCollector<A,​?,​A>` | `min()` | Returns a collector that finds a minimum value in a group of `Comparable` elements.
    `static <A> UniConstraintCollector<A,​?,​A>` | `min​(Comparator<A> comparator)` | As defined by `min()`, only with a custom `Comparator`.
    `static <A,​B,​Mapped extends Comparable<Mapped>> BiConstraintCollector<A,​B,​?,​Mapped>` | `min​(BiFunction<A,​B,​Mapped> groupValueMapping)` | As defined by `min(Function)`.
    `static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​Mapped>` | `min​(BiFunction<A,​B,​Mapped> groupValueMapping, Comparator<Mapped> comparator)` | As defined by `min(Function)`, only with a custom `Comparator`.
    `static <A,​Mapped extends Comparable<Mapped>> UniConstraintCollector<A,​?,​Mapped>` | `min​(Function<A,​Mapped> groupValueMapping)` | Returns a collector that finds a minimum value in a group of `Comparable` elements.
    `static <A,​Mapped> UniConstraintCollector<A,​?,​Mapped>` | `min​(Function<A,​Mapped> groupValueMapping, Comparator<Mapped> comparator)` | As defined by `min(Function)`, only with a custom `Comparator`.
    `static <A,​B,​C,​D,​Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped>` | `min​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)` | As defined by `min(Function)`.
    `static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped>` | `min​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping, Comparator<Mapped> comparator)` | As defined by `min(Function)`, only with a custom `Comparator`.
    `static <A,​B,​C,​Mapped extends Comparable<Mapped>> TriConstraintCollector<A,​B,​C,​?,​Mapped>` | `min​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)` | As defined by `min(Function)`.
    `static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​Mapped>` | `min​(TriFunction<A,​B,​C,​Mapped> groupValueMapping, Comparator<Mapped> comparator)` | As defined by `min(Function)`, only with a custom `Comparator`.
    `static <A,​B,​Result> BiConstraintCollector<A,​B,​?,​Result>` | `sum​(BiFunction<? super A,​? super B,​Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)` |
    `static <A,​Result> UniConstraintCollector<A,​?,​Result>` | `sum​(Function<? super A,​Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)` |
    `static <A,​B> BiConstraintCollector<A,​B,​?,​Integer>` | `sum​(ToIntBiFunction<? super A,​? super B> groupValueMapping)` |
    `static <A> UniConstraintCollector<A,​?,​Integer>` | `sum​(ToIntFunction<? super A> groupValueMapping)` |
    `static <A,​B,​C,​D,​Result> QuadConstraintCollector<A,​B,​C,​D,​?,​Result>` | `sum​(QuadFunction<? super A,​? super B,​? super C,​? super D,​Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)` |
    `static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Integer>` | `sum​(ToIntQuadFunction<? super A,​? super B,​? super C,​? super D> groupValueMapping)` |
    `static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Integer>` | `sum​(ToIntTriFunction<? super A,​? super B,​? super C> groupValueMapping)` |
    `static <A,​B,​C,​Result> TriConstraintCollector<A,​B,​C,​?,​Result>` | `sum​(TriFunction<? super A,​? super B,​? super C,​Result> groupValueMapping, Result zero, BinaryOperator<Result> adder, BinaryOperator<Result> subtractor)` |
    `static <A,​B> BiConstraintCollector<A,​B,​?,​BigDecimal>` | `sumBigDecimal​(BiFunction<? super A,​? super B,​BigDecimal> groupValueMapping)` |
    `static <A> UniConstraintCollector<A,​?,​BigDecimal>` | `sumBigDecimal​(Function<? super A,​BigDecimal> groupValueMapping)` |
    `static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​BigDecimal>` | `sumBigDecimal​(QuadFunction<? super A,​? super B,​? super C,​? super D,​BigDecimal> groupValueMapping)` |
    `static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​BigDecimal>` | `sumBigDecimal​(TriFunction<? super A,​? super B,​? super C,​BigDecimal> groupValueMapping)` |
    `static <A,​B> BiConstraintCollector<A,​B,​?,​BigInteger>` | `sumBigInteger​(BiFunction<? super A,​? super B,​BigInteger> groupValueMapping)` |
    `static <A> UniConstraintCollector<A,​?,​BigInteger>` | `sumBigInteger​(Function<? super A,​BigInteger> groupValueMapping)` |
    `static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​BigInteger>` | `sumBigInteger​(QuadFunction<? super A,​? super B,​? super C,​? super D,​BigInteger> groupValueMapping)` |
    `static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​BigInteger>` | `sumBigInteger​(TriFunction<? super A,​? super B,​? super C,​BigInteger> groupValueMapping)` |
    `static <A,​B> BiConstraintCollector<A,​B,​?,​Duration>` | `sumDuration​(BiFunction<? super A,​? super B,​Duration> groupValueMapping)` |
    `static <A> UniConstraintCollector<A,​?,​Duration>` | `sumDuration​(Function<? super A,​Duration> groupValueMapping)` |
    `static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Duration>` | `sumDuration​(QuadFunction<? super A,​? super B,​? super C,​? super D,​Duration> groupValueMapping)` |
    `static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Duration>` | `sumDuration​(TriFunction<? super A,​? super B,​? super C,​Duration> groupValueMapping)` |
    `static <A,​B> BiConstraintCollector<A,​B,​?,​Long>` | `sumLong​(ToLongBiFunction<? super A,​? super B> groupValueMapping)` |
    `static <A> UniConstraintCollector<A,​?,​Long>` | `sumLong​(ToLongFunction<? super A> groupValueMapping)` |
    `static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Long>` | `sumLong​(ToLongQuadFunction<? super A,​? super B,​? super C,​? super D> groupValueMapping)` |
    `static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Long>` | `sumLong​(ToLongTriFunction<? super A,​? super B,​? super C> groupValueMapping)` |
    `static <A,​B> BiConstraintCollector<A,​B,​?,​Period>` | `sumPeriod​(BiFunction<? super A,​? super B,​Period> groupValueMapping)` |
    `static <A> UniConstraintCollector<A,​?,​Period>` | `sumPeriod​(Function<? super A,​Period> groupValueMapping)` |
    `static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Period>` | `sumPeriod​(QuadFunction<? super A,​? super B,​? super C,​? super D,​Period> groupValueMapping)` |
    `static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Period>` | `sumPeriod​(TriFunction<? super A,​? super B,​? super C,​Period> groupValueMapping)` |
    `static <A,​B,​Mapped,​Result extends Collection<Mapped>> BiConstraintCollector<A,​B,​?,​Result>` | `toCollection​(BiFunction<A,​B,​Mapped> groupValueMapping, IntFunction<Result> collectionFunction)` |
    `static <A,​Mapped,​Result extends Collection<Mapped>> UniConstraintCollector<A,​?,​Result>` | `toCollection​(Function<A,​Mapped> groupValueMapping, IntFunction<Result> collectionFunction)` |
    `static <A,​Result extends Collection<A>> UniConstraintCollector<A,​?,​Result>` | `toCollection​(IntFunction<Result> collectionFunction)` |
    `static <A,​B,​C,​D,​Mapped,​Result extends Collection<Mapped>> QuadConstraintCollector<A,​B,​C,​D,​?,​Result>` | `toCollection​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping, IntFunction<Result> collectionFunction)` |
    `static <A,​B,​C,​Mapped,​Result extends Collection<Mapped>> TriConstraintCollector<A,​B,​C,​?,​Result>` | `toCollection​(TriFunction<A,​B,​C,​Mapped> groupValueMapping, IntFunction<Result> collectionFunction)` |
    `static <A> UniConstraintCollector<A,​?,​List<A>>` | `toList()` | Creates constraint collector that returns `List` of the same element type as the `ConstraintStream`.
    `static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​List<Mapped>>` | `toList​(BiFunction<A,​B,​Mapped> groupValueMapping)` | Creates constraint collector that returns `List` of the given element type.
    `static <A,​Mapped> UniConstraintCollector<A,​?,​List<Mapped>>` | `toList​(Function<A,​Mapped> groupValueMapping)` | Creates constraint collector that returns `List` of the given element type.
    `static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​List<Mapped>>` | `toList​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)` | Creates constraint collector that returns `List` of the given element type.
    `static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​List<Mapped>>` | `toList​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)` | Creates constraint collector that returns `List` of the given element type.
    `static <A,​B,​Key,​Value> BiConstraintCollector<A,​B,​?,​Map<Key,​Set<Value>>>` | `toMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper, BiFunction<? super A,​? super B,​? extends Value> valueMapper)` | As defined by `toMap(Function, Function)`.
    `static <A,​B,​Key,​Value> BiConstraintCollector<A,​B,​?,​Map<Key,​Value>>` | `toMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper, BiFunction<? super A,​? super B,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` | As defined by `toMap(Function, Function, BinaryOperator)`.
    `static <A,​B,​Key,​Value,​ValueSet extends Set<Value>> BiConstraintCollector<A,​B,​?,​Map<Key,​ValueSet>>` | `toMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper, BiFunction<? super A,​? super B,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` | As defined by `toMap(Function, Function, IntFunction)`.
    `static <A,​Key,​Value> UniConstraintCollector<A,​?,​Map<Key,​Set<Value>>>` | `toMap​(Function<? super A,​? extends Key> keyMapper, Function<? super A,​? extends Value> valueMapper)` | Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.
    `static <A,​Key,​Value> UniConstraintCollector<A,​?,​Map<Key,​Value>>` | `toMap​(Function<? super A,​? extends Key> keyMapper, Function<? super A,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` | Creates a constraint collector that returns a `Map`.
    `static <A,​Key,​Value,​ValueSet extends Set<Value>> UniConstraintCollector<A,​?,​Map<Key,​ValueSet>>` | `toMap​(Function<? super A,​? extends Key> keyMapper, Function<? super A,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` | Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.
    `static <A,​B,​C,​D,​Key,​Value> QuadConstraintCollector<A,​B,​C,​D,​?,​Map<Key,​Set<Value>>>` | `toMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper, QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper)` | As defined by `toMap(Function, Function)`.
    `static <A,​B,​C,​D,​Key,​Value> QuadConstraintCollector<A,​B,​C,​D,​?,​Map<Key,​Value>>` | `toMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper, QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` | As defined by `toMap(Function, Function, BinaryOperator)`.
    `static <A,​B,​C,​D,​Key,​Value,​ValueSet extends Set<Value>> QuadConstraintCollector<A,​B,​C,​D,​?,​Map<Key,​ValueSet>>` | `toMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper, QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` | As defined by `toMap(Function, Function, IntFunction)`.
    `static <A,​B,​C,​Key,​Value> TriConstraintCollector<A,​B,​C,​?,​Map<Key,​Set<Value>>>` | `toMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper, TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper)` | As defined by `toMap(Function, Function)`.
    `static <A,​B,​C,​Key,​Value> TriConstraintCollector<A,​B,​C,​?,​Map<Key,​Value>>` | `toMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper, TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` | As defined by `toMap(Function, Function, BinaryOperator)`.
    `static <A,​B,​C,​Key,​Value,​ValueSet extends Set<Value>> TriConstraintCollector<A,​B,​C,​?,​Map<Key,​ValueSet>>` | `toMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper, TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` | As defined by `toMap(Function, Function, IntFunction)`.
    `static <A> UniConstraintCollector<A,​?,​Set<A>>` | `toSet()` | Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`.
    `static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​Set<Mapped>>` | `toSet​(BiFunction<A,​B,​Mapped> groupValueMapping)` | As defined by `toSet(Function)`.
    `static <A,​Mapped> UniConstraintCollector<A,​?,​Set<Mapped>>` | `toSet​(Function<A,​Mapped> groupValueMapping)` | Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`.
    `static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​Set<Mapped>>` | `toSet​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)` | As defined by `toSet(Function)`.
    `static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​Set<Mapped>>` | `toSet​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)` | As defined by `toSet(Function)`.
    `static <A,​B,​Key extends Comparable<Key>,​Value> BiConstraintCollector<A,​B,​?,​SortedMap<Key,​Set<Value>>>` | `toSortedMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper, BiFunction<? super A,​? super B,​? extends Value> valueMapper)` | As defined by `toSortedMap(Function, Function)`.
    `static <A,​B,​Key extends Comparable<Key>,​Value> BiConstraintCollector<A,​B,​?,​SortedMap<Key,​Value>>` | `toSortedMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper, BiFunction<? super A,​? super B,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` | As defined by `toSortedMap(Function, Function, BinaryOperator)`.
    `static <A,​B,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>> BiConstraintCollector<A,​B,​?,​SortedMap<Key,​ValueSet>>` | `toSortedMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper, BiFunction<? super A,​? super B,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` | As defined by `toSortedMap(Function, Function, IntFunction)`.
    `static <A,​Key extends Comparable<Key>,​Value> UniConstraintCollector<A,​?,​SortedMap<Key,​Set<Value>>>` | `toSortedMap​(Function<? super A,​? extends Key> keyMapper, Function<? super A,​? extends Value> valueMapper)` | Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.
    `static <A,​Key extends Comparable<Key>,​Value> UniConstraintCollector<A,​?,​SortedMap<Key,​Value>>` | `toSortedMap​(Function<? super A,​? extends Key> keyMapper, Function<? super A,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` | Creates a constraint collector that returns a `SortedMap`.
    `static <A,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>> UniConstraintCollector<A,​?,​SortedMap<Key,​ValueSet>>` | `toSortedMap​(Function<? super A,​? extends Key> keyMapper, Function<? super A,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` | Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.
    `static <A,​B,​C,​D,​Key extends Comparable<Key>,​Value> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedMap<Key,​Set<Value>>>` | `toSortedMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper, QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper)` | As defined by `toSortedMap(Function, Function)`.
    `static <A,​B,​C,​D,​Key extends Comparable<Key>,​Value> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedMap<Key,​Value>>` | `toSortedMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper, QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` | As defined by `toSortedMap(Function, Function, BinaryOperator)`.
    `static <A,​B,​C,​D,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedMap<Key,​ValueSet>>` | `toSortedMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper, QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` | As defined by `toSortedMap(Function, Function, IntFunction)`.
    `static <A,​B,​C,​Key extends Comparable<Key>,​Value> TriConstraintCollector<A,​B,​C,​?,​SortedMap<Key,​Set<Value>>>` | `toSortedMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper, TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper)` | As defined by `toSortedMap(Function, Function)`.
    `static <A,​B,​C,​Key extends Comparable<Key>,​Value> TriConstraintCollector<A,​B,​C,​?,​SortedMap<Key,​Value>>` | `toSortedMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper, TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper, BinaryOperator<Value> mergeFunction)` | As defined by `toSortedMap(Function, Function, BinaryOperator)`.
    `static <A,​B,​C,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>> TriConstraintCollector<A,​B,​C,​?,​SortedMap<Key,​ValueSet>>` | `toSortedMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper, TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper, IntFunction<ValueSet> valueSetFunction)` | As defined by `toSortedMap(Function, Function, IntFunction)`.
    `static <A extends Comparable<A>> UniConstraintCollector<A,​?,​SortedSet<A>>` | `toSortedSet()` | Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.
    `static <A,​B,​Mapped extends Comparable<Mapped>> BiConstraintCollector<A,​B,​?,​SortedSet<Mapped>>` | `toSortedSet​(BiFunction<A,​B,​Mapped> groupValueMapping)` | As defined by `toSortedSet(Function)`.
    `static <A,​Mapped extends Comparable<Mapped>> UniConstraintCollector<A,​?,​SortedSet<Mapped>>` | `toSortedSet​(Function<A,​Mapped> groupValueMapping)` | Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.
    `static <A,​B,​C,​D,​Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedSet<Mapped>>` | `toSortedSet​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)` | As defined by `toSortedSet(Function)`.
    `static <A,​B,​C,​Mapped extends Comparable<Mapped>> TriConstraintCollector<A,​B,​C,​?,​SortedSet<Mapped>>` | `toSortedSet​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)` | As defined by `toSortedSet(Function)`.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### count

          public static <A> UniConstraintCollector<A,​?,​Integer> count()

    - #### countLong

          public static <A> UniConstraintCollector<A,​?,​Long> countLong()

    - #### countBi

          public static <A,​B> BiConstraintCollector<A,​B,​?,​Integer> countBi()

    - #### countLongBi

          public static <A,​B> BiConstraintCollector<A,​B,​?,​Long> countLongBi()

    - #### countTri

          public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Integer> countTri()

    - #### countLongTri

          public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Long> countLongTri()

    - #### countQuad

          public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Integer> countQuad()

    - #### countLongQuad

          public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Long> countLongQuad()

    - #### countDistinct

          public static <A> UniConstraintCollector<A,​?,​Integer> countDistinct()

    - #### countDistinct

          public static <A> UniConstraintCollector<A,​?,​Integer> countDistinct​(Function<A,​?> groupValueMapping)

    - #### countDistinctLong

          public static <A> UniConstraintCollector<A,​?,​Long> countDistinctLong​(Function<A,​?> groupValueMapping)

    - #### countDistinct

          public static <A,​B> BiConstraintCollector<A,​B,​?,​Integer> countDistinct​(BiFunction<A,​B,​?> groupValueMapping)

    - #### countDistinctLong

          public static <A,​B> BiConstraintCollector<A,​B,​?,​Long> countDistinctLong​(BiFunction<A,​B,​?> groupValueMapping)

    - #### countDistinct

          public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Integer> countDistinct​(TriFunction<A,​B,​C,​?> groupValueMapping)

    - #### countDistinctLong

          public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Long> countDistinctLong​(TriFunction<A,​B,​C,​?> groupValueMapping)

    - #### countDistinct

          public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Integer> countDistinct​(QuadFunction<A,​B,​C,​D,​?> groupValueMapping)

    - #### countDistinctLong

          public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Long> countDistinctLong​(QuadFunction<A,​B,​C,​D,​?> groupValueMapping)

    - #### sum

          public static <A> UniConstraintCollector<A,​?,​Integer> sum​(ToIntFunction<? super A> groupValueMapping)

    - #### sumLong

          public static <A> UniConstraintCollector<A,​?,​Long> sumLong​(ToLongFunction<? super A> groupValueMapping)

    - #### sum

          public static <A,​Result> UniConstraintCollector<A,​?,​Result> sum​(Function<? super A,​Result> groupValueMapping,
                                                                                            Result zero,
                                                                                            BinaryOperator<Result> adder,
                                                                                            BinaryOperator<Result> subtractor)

    - #### sumBigDecimal

          public static <A> UniConstraintCollector<A,​?,​BigDecimal> sumBigDecimal​(Function<? super A,​BigDecimal> groupValueMapping)

    - #### sumBigInteger

          public static <A> UniConstraintCollector<A,​?,​BigInteger> sumBigInteger​(Function<? super A,​BigInteger> groupValueMapping)

    - #### sumDuration

          public static <A> UniConstraintCollector<A,​?,​Duration> sumDuration​(Function<? super A,​Duration> groupValueMapping)

    - #### sumPeriod

          public static <A> UniConstraintCollector<A,​?,​Period> sumPeriod​(Function<? super A,​Period> groupValueMapping)

    - #### sum

          public static <A,​B> BiConstraintCollector<A,​B,​?,​Integer> sum​(ToIntBiFunction<? super A,​? super B> groupValueMapping)

    - #### sumLong

          public static <A,​B> BiConstraintCollector<A,​B,​?,​Long> sumLong​(ToLongBiFunction<? super A,​? super B> groupValueMapping)

    - #### sum

          public static <A,​B,​Result> BiConstraintCollector<A,​B,​?,​Result> sum​(BiFunction<? super A,​? super B,​Result> groupValueMapping,
                                                                                                           Result zero,
                                                                                                           BinaryOperator<Result> adder,
                                                                                                           BinaryOperator<Result> subtractor)

    - #### sumBigDecimal

          public static <A,​B> BiConstraintCollector<A,​B,​?,​BigDecimal> sumBigDecimal​(BiFunction<? super A,​? super B,​BigDecimal> groupValueMapping)

    - #### sumBigInteger

          public static <A,​B> BiConstraintCollector<A,​B,​?,​BigInteger> sumBigInteger​(BiFunction<? super A,​? super B,​BigInteger> groupValueMapping)

    - #### sumDuration

          public static <A,​B> BiConstraintCollector<A,​B,​?,​Duration> sumDuration​(BiFunction<? super A,​? super B,​Duration> groupValueMapping)

    - #### sumPeriod

          public static <A,​B> BiConstraintCollector<A,​B,​?,​Period> sumPeriod​(BiFunction<? super A,​? super B,​Period> groupValueMapping)

    - #### sum

          public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Integer> sum​(ToIntTriFunction<? super A,​? super B,​? super C> groupValueMapping)

    - #### sumLong

          public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Long> sumLong​(ToLongTriFunction<? super A,​? super B,​? super C> groupValueMapping)

    - #### sum

          public static <A,​B,​C,​Result> TriConstraintCollector<A,​B,​C,​?,​Result> sum​(TriFunction<? super A,​? super B,​? super C,​Result> groupValueMapping,
                                                                                                                            Result zero,
                                                                                                                            BinaryOperator<Result> adder,
                                                                                                                            BinaryOperator<Result> subtractor)

    - #### sumBigDecimal

          public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​BigDecimal> sumBigDecimal​(TriFunction<? super A,​? super B,​? super C,​BigDecimal> groupValueMapping)

    - #### sumBigInteger

          public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​BigInteger> sumBigInteger​(TriFunction<? super A,​? super B,​? super C,​BigInteger> groupValueMapping)

    - #### sumDuration

          public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Duration> sumDuration​(TriFunction<? super A,​? super B,​? super C,​Duration> groupValueMapping)

    - #### sumPeriod

          public static <A,​B,​C> TriConstraintCollector<A,​B,​C,​?,​Period> sumPeriod​(TriFunction<? super A,​? super B,​? super C,​Period> groupValueMapping)

    - #### sum

          public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Integer> sum​(ToIntQuadFunction<? super A,​? super B,​? super C,​? super D> groupValueMapping)

    - #### sumLong

          public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Long> sumLong​(ToLongQuadFunction<? super A,​? super B,​? super C,​? super D> groupValueMapping)

    - #### sum

          public static <A,​B,​C,​D,​Result> QuadConstraintCollector<A,​B,​C,​D,​?,​Result> sum​(QuadFunction<? super A,​? super B,​? super C,​? super D,​Result> groupValueMapping,
                                                                                                                                             Result zero,
                                                                                                                                             BinaryOperator<Result> adder,
                                                                                                                                             BinaryOperator<Result> subtractor)

    - #### sumBigDecimal

          public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​BigDecimal> sumBigDecimal​(QuadFunction<? super A,​? super B,​? super C,​? super D,​BigDecimal> groupValueMapping)

    - #### sumBigInteger

          public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​BigInteger> sumBigInteger​(QuadFunction<? super A,​? super B,​? super C,​? super D,​BigInteger> groupValueMapping)

    - #### sumDuration

          public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Duration> sumDuration​(QuadFunction<? super A,​? super B,​? super C,​? super D,​Duration> groupValueMapping)

    - #### sumPeriod

          public static <A,​B,​C,​D> QuadConstraintCollector<A,​B,​C,​D,​?,​Period> sumPeriod​(QuadFunction<? super A,​? super B,​? super C,​? super D,​Period> groupValueMapping)

    - #### min

          public static <A extends Comparable<A>> UniConstraintCollector<A,​?,​A> min()

      Returns a collector that finds a minimum value in a group of `Comparable` elements.

      Important: The `Comparable`'s `Comparable.compareTo(Object)` must be consistent with equals, such that `e1.compareTo(e2) == 0` has the same boolean value as `e1.equals(e2)`. In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same `PlanningSolution` state, due to incremental score calculation.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(min())` returns either `Ann` or `Eric` arbitrarily, assuming the objects are `Comparable` by the `age` field. To avoid this, always end your `Comparator` by an identity comparison, such as `Comparator.comparing(Person::getAge).comparing(Person::getId))`.

      Type Parameters:
        `A` - type of the matched fact
      Returns:
        never null

    - #### min

          public static <A,​Mapped extends Comparable<Mapped>> UniConstraintCollector<A,​?,​Mapped> min​(Function<A,​Mapped> groupValueMapping)

      Returns a collector that finds a minimum value in a group of `Comparable` elements.

      Important: The `Comparable`'s `Comparable.compareTo(Object)` must be consistent with equals, such that `e1.compareTo(e2) == 0` has the same boolean value as `e1.equals(e2)`. In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same `PlanningSolution` state, due to incremental score calculation.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(min(Person::getAge))` returns `20`.

      Type Parameters:
        `A` - type of the matched fact
        `Mapped` - type of the result
      Parameters:
        `groupValueMapping` - never null, maps facts from the matched type to the result type
      Returns:
        never null

    - #### min

          public static <A> UniConstraintCollector<A,​?,​A> min​(Comparator<A> comparator)

      As defined by `min()`, only with a custom `Comparator`.

    - #### min

          public static <A,​Mapped> UniConstraintCollector<A,​?,​Mapped> min​(Function<A,​Mapped> groupValueMapping,
                                                                                            Comparator<Mapped> comparator)

      As defined by `min(Function)`, only with a custom `Comparator`.

    - #### min

          public static <A,​B,​Mapped extends Comparable<Mapped>> BiConstraintCollector<A,​B,​?,​Mapped> min​(BiFunction<A,​B,​Mapped> groupValueMapping)

      As defined by `min(Function)`.

    - #### min

          public static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​Mapped> min​(BiFunction<A,​B,​Mapped> groupValueMapping,
                                                                                                           Comparator<Mapped> comparator)

      As defined by `min(Function)`, only with a custom `Comparator`.

    - #### min

          public static <A,​B,​C,​Mapped extends Comparable<Mapped>> TriConstraintCollector<A,​B,​C,​?,​Mapped> min​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)

      As defined by `min(Function)`.

    - #### min

          public static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​Mapped> min​(TriFunction<A,​B,​C,​Mapped> groupValueMapping,
                                                                                                                            Comparator<Mapped> comparator)

      As defined by `min(Function)`, only with a custom `Comparator`.

    - #### min

          public static <A,​B,​C,​D,​Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped> min​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)

      As defined by `min(Function)`.

    - #### min

          public static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped> min​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping,
                                                                                                                                             Comparator<Mapped> comparator)

      As defined by `min(Function)`, only with a custom `Comparator`.

    - #### max

          public static <A extends Comparable<A>> UniConstraintCollector<A,​?,​A> max()

      Returns a collector that finds a maximum value in a group of `Comparable` elements.

      Important: The `Comparable`'s `Comparable.compareTo(Object)` must be consistent with equals, such that `e1.compareTo(e2) == 0` has the same boolean value as `e1.equals(e2)`. In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same `PlanningSolution` state, due to incremental score calculation.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(max())` returns either `Cathy` or `David` arbitrarily, assuming the objects are `Comparable` by the `age` field. To avoid this, always end your `Comparator` by an identity comparison, such as `Comparator.comparing(Person::getAge).comparing(Person::getId))`.

      Type Parameters:
        `A` - type of the matched fact
      Returns:
        never null

    - #### max

          public static <A,​Mapped extends Comparable<Mapped>> UniConstraintCollector<A,​?,​Mapped> max​(Function<A,​Mapped> groupValueMapping)

      Returns a collector that finds a maximum value in a group of `Comparable` elements.

      Important: The `Comparable`'s `Comparable.compareTo(Object)` must be consistent with equals, such that `e1.compareTo(e2) == 0` has the same boolean value as `e1.equals(e2)`. In other words, if two elements compare to zero, any of them can be returned by the collector. It can even differ between 2 score calculations on the exact same `PlanningSolution` state, due to incremental score calculation.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(max(Person::getAge))` returns `30`.

      Type Parameters:
        `A` - type of the matched fact
        `Mapped` - type of the result
      Parameters:
        `groupValueMapping` - never null, maps facts from the matched type to the result type
      Returns:
        never null

    - #### max

          public static <A> UniConstraintCollector<A,​?,​A> max​(Comparator<A> comparator)

      As defined by `max()`, only with a custom `Comparator`.

    - #### max

          public static <A,​Mapped> UniConstraintCollector<A,​?,​Mapped> max​(Function<A,​Mapped> groupValueMapping,
                                                                                            Comparator<Mapped> comparator)

      As defined by `max(Function)`, only with a custom `Comparator`.

    - #### max

          public static <A,​B,​Mapped extends Comparable<Mapped>> BiConstraintCollector<A,​B,​?,​Mapped> max​(BiFunction<A,​B,​Mapped> groupValueMapping)

      As defined by `max(Function)`.

    - #### max

          public static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​Mapped> max​(BiFunction<A,​B,​Mapped> groupValueMapping,
                                                                                                           Comparator<Mapped> comparator)

      As defined by `max(Function)`, only with a custom `Comparator`.

    - #### max

          public static <A,​B,​C,​Mapped extends Comparable<Mapped>> TriConstraintCollector<A,​B,​C,​?,​Mapped> max​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)

      As defined by `max(Function)`.

    - #### max

          public static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​Mapped> max​(TriFunction<A,​B,​C,​Mapped> groupValueMapping,
                                                                                                                            Comparator<Mapped> comparator)

      As defined by `max(Function)`, only with a custom `Comparator`.

    - #### max

          public static <A,​B,​C,​D,​Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped> max​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)

      As defined by `max(Function)`.

    - #### max

          public static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​Mapped> max​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping,
                                                                                                                                             Comparator<Mapped> comparator)

      As defined by `max(Function)`, only with a custom `Comparator`.

    - #### toCollection

          public static <A,​Result extends Collection<A>> UniConstraintCollector<A,​?,​Result> toCollection​(IntFunction<Result> collectionFunction)

    - #### toSet

          public static <A> UniConstraintCollector<A,​?,​Set<A>> toSet()

      Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet()`.
      Type Parameters:
        `A` - type of the matched fact
      Returns:
        never null

    - #### toSortedSet

          public static <A extends Comparable<A>> UniConstraintCollector<A,​?,​SortedSet<A>> toSortedSet()

      Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.
      Type Parameters:
        `A` - type of the matched fact
      Returns:
        never null

    - #### toList

          public static <A> UniConstraintCollector<A,​?,​List<A>> toList()

      Creates constraint collector that returns `List` of the same element type as the `ConstraintStream`. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet()`.
      Type Parameters:
        `A` - type of the matched fact
      Returns:
        never null

    - #### toCollection

          public static <A,​Mapped,​Result extends Collection<Mapped>> UniConstraintCollector<A,​?,​Result> toCollection​(Function<A,​Mapped> groupValueMapping,
                                                                                                                                             IntFunction<Result> collectionFunction)

    - #### toSet

          public static <A,​Mapped> UniConstraintCollector<A,​?,​Set<Mapped>> toSet​(Function<A,​Mapped> groupValueMapping)

      Creates constraint collector that returns `Set` of the same element type as the `ConstraintStream`. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet()`.
      Type Parameters:
        `A` - type of the matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toSortedSet

          public static <A,​Mapped extends Comparable<Mapped>> UniConstraintCollector<A,​?,​SortedSet<Mapped>> toSortedSet​(Function<A,​Mapped> groupValueMapping)

      Creates constraint collector that returns `SortedSet` of the same element type as the `ConstraintStream`.
      Type Parameters:
        `A` - type of the matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toList

          public static <A,​Mapped> UniConstraintCollector<A,​?,​List<Mapped>> toList​(Function<A,​Mapped> groupValueMapping)

      Creates constraint collector that returns `List` of the given element type. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet(Function)`.
      Type Parameters:
        `A` - type of the matched fact
        `Mapped` - type of elements in the resulting collection
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting collection
      Returns:
        never null

    - #### toCollection

          public static <A,​B,​Mapped,​Result extends Collection<Mapped>> BiConstraintCollector<A,​B,​?,​Result> toCollection​(BiFunction<A,​B,​Mapped> groupValueMapping,
                                                                                                                                                            IntFunction<Result> collectionFunction)

    - #### toSet

          public static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​Set<Mapped>> toSet​(BiFunction<A,​B,​Mapped> groupValueMapping)

      As defined by `toSet(Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toSortedSet

          public static <A,​B,​Mapped extends Comparable<Mapped>> BiConstraintCollector<A,​B,​?,​SortedSet<Mapped>> toSortedSet​(BiFunction<A,​B,​Mapped> groupValueMapping)

      As defined by `toSortedSet(Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toList

          public static <A,​B,​Mapped> BiConstraintCollector<A,​B,​?,​List<Mapped>> toList​(BiFunction<A,​B,​Mapped> groupValueMapping)

      Creates constraint collector that returns `List` of the given element type. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet(BiFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Mapped` - type of elements in the resulting collection
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting collection
      Returns:
        never null

    - #### toCollection

          public static <A,​B,​C,​Mapped,​Result extends Collection<Mapped>> TriConstraintCollector<A,​B,​C,​?,​Result> toCollection​(TriFunction<A,​B,​C,​Mapped> groupValueMapping,
                                                                                                                                                                             IntFunction<Result> collectionFunction)

    - #### toSet

          public static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​Set<Mapped>> toSet​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)

      As defined by `toSet(Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toSortedSet

          public static <A,​B,​C,​Mapped extends Comparable<Mapped>> TriConstraintCollector<A,​B,​C,​?,​SortedSet<Mapped>> toSortedSet​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)

      As defined by `toSortedSet(Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toList

          public static <A,​B,​C,​Mapped> TriConstraintCollector<A,​B,​C,​?,​List<Mapped>> toList​(TriFunction<A,​B,​C,​Mapped> groupValueMapping)

      Creates constraint collector that returns `List` of the given element type. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet(TriFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Mapped` - type of elements in the resulting collection
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting collection
      Returns:
        never null

    - #### toCollection

          public static <A,​B,​C,​D,​Mapped,​Result extends Collection<Mapped>> QuadConstraintCollector<A,​B,​C,​D,​?,​Result> toCollection​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping,
                                                                                                                                                                                              IntFunction<Result> collectionFunction)

    - #### toSet

          public static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​Set<Mapped>> toSet​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)

      As defined by `toSet(Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toSortedSet

          public static <A,​B,​C,​D,​Mapped extends Comparable<Mapped>> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedSet<Mapped>> toSortedSet​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)

      As defined by `toSortedSet(Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Mapped` - type of elements in the resulting set
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting set
      Returns:
        never null

    - #### toList

          public static <A,​B,​C,​D,​Mapped> QuadConstraintCollector<A,​B,​C,​D,​?,​List<Mapped>> toList​(QuadFunction<A,​B,​C,​D,​Mapped> groupValueMapping)

      Creates constraint collector that returns `List` of the given element type. Makes no guarantees on iteration order. For stable iteration order, use `toSortedSet(QuadFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Mapped` - type of elements in the resulting collection
      Parameters:
        `groupValueMapping` - never null, converts matched facts to elements of the resulting collection
      Returns:
        never null

    - #### toMap

          public static <A,​Key,​Value> UniConstraintCollector<A,​?,​Map<Key,​Set<Value>>> toMap​(Function<? super A,​? extends Key> keyMapper,
                                                                                                                          Function<? super A,​? extends Value> valueMapper)

      Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName))` returns `{20: [Ann, Eric], 25: [Beth], 30: [Cathy, David]}`.

      Makes no guarantees on iteration order, neither for map entries, nor for the value sets. For stable iteration order, use `toSortedMap(Function, Function, IntFunction)`.

      Type Parameters:
        `A` - type of the matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toMap

          public static <A,​Key,​Value,​ValueSet extends Set<Value>> UniConstraintCollector<A,​?,​Map<Key,​ValueSet>> toMap​(Function<? super A,​? extends Key> keyMapper,
                                                                                                                                                          Function<? super A,​? extends Value> valueMapper,
                                                                                                                                                          IntFunction<ValueSet> valueSetFunction)

      Creates a constraint collector that returns a `Map` with given keys and values consisting of a `Set` of mappings.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName))` returns `{20: [Ann, Eric], 25: [Beth], 30: [Cathy, David]}`.

      Iteration order of value collections depends on the `Set` provided. Makes no guarantees on iteration order for map entries, use `toSortedMap(Function, Function, IntFunction)` for that.

      Type Parameters:
        `A` - type of the matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toMap

          public static <A,​Key,​Value> UniConstraintCollector<A,​?,​Map<Key,​Value>> toMap​(Function<? super A,​? extends Key> keyMapper,
                                                                                                                     Function<? super A,​? extends Value> valueMapper,
                                                                                                                     BinaryOperator<Value> mergeFunction)

      Creates a constraint collector that returns a `Map`.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName, (name1, name2) -> name1 + " and " + name2)` returns `{20: "Ann and Eric", 25: "Beth", 30: "Cathy and David"}`.

      Makes no guarantees on iteration order for map entries. For stable iteration order, use `toSortedMap(Function, Function, BinaryOperator)`.

      Type Parameters:
        `A` - type of the matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toSortedMap

          public static <A,​Key extends Comparable<Key>,​Value> UniConstraintCollector<A,​?,​SortedMap<Key,​Set<Value>>> toSortedMap​(Function<? super A,​? extends Key> keyMapper,
                                                                                                                                                              Function<? super A,​? extends Value> valueMapper)

      Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName))` returns `{20: [Ann, Eric], 25: [Beth], 30: [Cathy, David]}`.

      Makes no guarantees on iteration order for the value sets, use `toSortedMap(Function, Function, IntFunction)` for that.

      Type Parameters:
        `A` - type of the matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toSortedMap

          public static <A,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>> UniConstraintCollector<A,​?,​SortedMap<Key,​ValueSet>> toSortedMap​(Function<? super A,​? extends Key> keyMapper,
                                                                                                                                                                                              Function<? super A,​? extends Value> valueMapper,
                                                                                                                                                                                              IntFunction<ValueSet> valueSetFunction)

      Creates a constraint collector that returns a `SortedMap` with given keys and values consisting of a `Set` of mappings.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName))` returns `{20: [Ann, Eric], 25: [Beth], 30: [Cathy, David]}`.

      Iteration order of value collections depends on the `Set` provided.

      Type Parameters:
        `A` - type of the matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toSortedMap

          public static <A,​Key extends Comparable<Key>,​Value> UniConstraintCollector<A,​?,​SortedMap<Key,​Value>> toSortedMap​(Function<? super A,​? extends Key> keyMapper,
                                                                                                                                                         Function<? super A,​? extends Value> valueMapper,
                                                                                                                                                         BinaryOperator<Value> mergeFunction)

      Creates a constraint collector that returns a `SortedMap`.

      For example, `[Ann(age = 20), Beth(age = 25), Cathy(age = 30), David(age = 30), Eric(age = 20)]` with `.groupBy(toMap(Person::getAge, Person::getName, (name1, name2) -> name1 + " and " + name2)` returns `{20: "Ann and Eric", 25: "Beth", 30: "Cathy and David"}`.

      Type Parameters:
        `A` - type of the matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toMap

          public static <A,​B,​Key,​Value> BiConstraintCollector<A,​B,​?,​Map<Key,​Set<Value>>> toMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper,
                                                                                                                                         BiFunction<? super A,​? super B,​? extends Value> valueMapper)

      As defined by `toMap(Function, Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toMap

          public static <A,​B,​Key,​Value,​ValueSet extends Set<Value>> BiConstraintCollector<A,​B,​?,​Map<Key,​ValueSet>> toMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper,
                                                                                                                                                                         BiFunction<? super A,​? super B,​? extends Value> valueMapper,
                                                                                                                                                                         IntFunction<ValueSet> valueSetFunction)

      As defined by `toMap(Function, Function, IntFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toMap

          public static <A,​B,​Key,​Value> BiConstraintCollector<A,​B,​?,​Map<Key,​Value>> toMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper,
                                                                                                                                    BiFunction<? super A,​? super B,​? extends Value> valueMapper,
                                                                                                                                    BinaryOperator<Value> mergeFunction)

      As defined by `toMap(Function, Function, BinaryOperator)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toSortedMap

          public static <A,​B,​Key extends Comparable<Key>,​Value> BiConstraintCollector<A,​B,​?,​SortedMap<Key,​Set<Value>>> toSortedMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper,
                                                                                                                                                                             BiFunction<? super A,​? super B,​? extends Value> valueMapper)

      As defined by `toSortedMap(Function, Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toSortedMap

          public static <A,​B,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>> BiConstraintCollector<A,​B,​?,​SortedMap<Key,​ValueSet>> toSortedMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper,
                                                                                                                                                                                                             BiFunction<? super A,​? super B,​? extends Value> valueMapper,
                                                                                                                                                                                                             IntFunction<ValueSet> valueSetFunction)

      As defined by `toSortedMap(Function, Function, IntFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toSortedMap

          public static <A,​B,​Key extends Comparable<Key>,​Value> BiConstraintCollector<A,​B,​?,​SortedMap<Key,​Value>> toSortedMap​(BiFunction<? super A,​? super B,​? extends Key> keyMapper,
                                                                                                                                                                        BiFunction<? super A,​? super B,​? extends Value> valueMapper,
                                                                                                                                                                        BinaryOperator<Value> mergeFunction)

      As defined by `toSortedMap(Function, Function, BinaryOperator)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toMap

          public static <A,​B,​C,​Key,​Value> TriConstraintCollector<A,​B,​C,​?,​Map<Key,​Set<Value>>> toMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper,
                                                                                                                                                          TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper)

      As defined by `toMap(Function, Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toMap

          public static <A,​B,​C,​Key,​Value,​ValueSet extends Set<Value>> TriConstraintCollector<A,​B,​C,​?,​Map<Key,​ValueSet>> toMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper,
                                                                                                                                                                                          TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper,
                                                                                                                                                                                          IntFunction<ValueSet> valueSetFunction)

      As defined by `toMap(Function, Function, IntFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toMap

          public static <A,​B,​C,​Key,​Value> TriConstraintCollector<A,​B,​C,​?,​Map<Key,​Value>> toMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper,
                                                                                                                                                     TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper,
                                                                                                                                                     BinaryOperator<Value> mergeFunction)

      As defined by `toMap(Function, Function, BinaryOperator)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toSortedMap

          public static <A,​B,​C,​Key extends Comparable<Key>,​Value> TriConstraintCollector<A,​B,​C,​?,​SortedMap<Key,​Set<Value>>> toSortedMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper,
                                                                                                                                                                                              TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper)

      As defined by `toSortedMap(Function, Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toSortedMap

          public static <A,​B,​C,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>> TriConstraintCollector<A,​B,​C,​?,​SortedMap<Key,​ValueSet>> toSortedMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper,
                                                                                                                                                                                                                              TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper,
                                                                                                                                                                                                                              IntFunction<ValueSet> valueSetFunction)

      As defined by `toSortedMap(Function, Function, IntFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toSortedMap

          public static <A,​B,​C,​Key extends Comparable<Key>,​Value> TriConstraintCollector<A,​B,​C,​?,​SortedMap<Key,​Value>> toSortedMap​(TriFunction<? super A,​? super B,​? super C,​? extends Key> keyMapper,
                                                                                                                                                                                         TriFunction<? super A,​? super B,​? super C,​? extends Value> valueMapper,
                                                                                                                                                                                         BinaryOperator<Value> mergeFunction)

      As defined by `toSortedMap(Function, Function, BinaryOperator)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toMap

          public static <A,​B,​C,​D,​Key,​Value> QuadConstraintCollector<A,​B,​C,​D,​?,​Map<Key,​Set<Value>>> toMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper,
                                                                                                                                                                           QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper)

      As defined by `toMap(Function, Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toMap

          public static <A,​B,​C,​D,​Key,​Value,​ValueSet extends Set<Value>> QuadConstraintCollector<A,​B,​C,​D,​?,​Map<Key,​ValueSet>> toMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper,
                                                                                                                                                                                                           QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper,
                                                                                                                                                                                                           IntFunction<ValueSet> valueSetFunction)

      As defined by `toMap(Function, Function, IntFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toMap

          public static <A,​B,​C,​D,​Key,​Value> QuadConstraintCollector<A,​B,​C,​D,​?,​Map<Key,​Value>> toMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper,
                                                                                                                                                                      QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper,
                                                                                                                                                                      BinaryOperator<Value> mergeFunction)

      As defined by `toMap(Function, Function, BinaryOperator)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null

    - #### toSortedMap

          public static <A,​B,​C,​D,​Key extends Comparable<Key>,​Value> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedMap<Key,​Set<Value>>> toSortedMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper,
                                                                                                                                                                                                               QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper)

      As defined by `toSortedMap(Function, Function)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
      Returns:
        never null

    - #### toSortedMap

          public static <A,​B,​C,​D,​Key extends Comparable<Key>,​Value,​ValueSet extends Set<Value>> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedMap<Key,​ValueSet>> toSortedMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper,
                                                                                                                                                                                                                                               QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper,
                                                                                                                                                                                                                                               IntFunction<ValueSet> valueSetFunction)

      As defined by `toSortedMap(Function, Function, IntFunction)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Key` - type of map key
        `Value` - type of map value
        `ValueSet` - type of the value set
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `valueSetFunction` - creates a set that will be used to store value mappings
      Returns:
        never null

    - #### toSortedMap

          public static <A,​B,​C,​D,​Key extends Comparable<Key>,​Value> QuadConstraintCollector<A,​B,​C,​D,​?,​SortedMap<Key,​Value>> toSortedMap​(QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Key> keyMapper,
                                                                                                                                                                                                          QuadFunction<? super A,​? super B,​? super C,​? super D,​? extends Value> valueMapper,
                                                                                                                                                                                                          BinaryOperator<Value> mergeFunction)

      As defined by `toSortedMap(Function, Function, BinaryOperator)`.
      Type Parameters:
        `A` - type of the first matched fact
        `B` - type of the second matched fact
        `C` - type of the third matched fact
        `D` - type of the fourth matched fact
        `Key` - type of map key
        `Value` - type of map value
      Parameters:
        `keyMapper` - map matched fact to a map key
        `valueMapper` - map matched fact to a value
        `mergeFunction` - takes two values and merges them to one
      Returns:
        never null