anchor.diff:      }
   ----
   
  -The return value for this collector is a 32-bit signed integer (`int`). There are also the following variants:
  -
  -* 64-bit variant `sumLong()`
  -* `java.math.BigDecimal`-based variant `sumBigDecimal()`
  -* `java.math.BigInteger`-based variant `sumBigInteger()`
  -* `java.time.Duration`-based variant `sumDuration()`
  -* `java.time.Period`-based variant `sumPeriod()`
  -* generic `sum()` variant for summing up custom types.
  -
  -
  -[collectorsMinMax]
  -===== Minimums and maximums
  -
  -To extract the minimum or maximum of a group, use the `ConstraintCollectors.min(...)` and
  +The sum is collected in an `int`. Variants of this collector:
  +
  +* `sumLong()` collects a `long` value instead of an `int` value.
  +* `sumBigDecimal()` collects a `java.math.BigDecimal` value instead of an `int` value.
  +* `sumBigInteger()` collects a `java.math.BigInteger` value instead of an `int` value.
  +* `sumDuration()` collects a `java.time.Duration` value instead of an `int` value.
  +* `sumPeriod()` collects a `java.time.Period` value instead of an `int` value.
  +* a generic `sum()` variant for summing up custom types
  +
  +
  +[[collectorsMinMax]]
  +===== `min()` and `max()` collectors
  +
  +To extract the minimum or maximum per group, use the `ConstraintCollectors.min(...)` and
   `ConstraintCollectors.max(...)` collectors respectively.
   
   These collectors operate on values of properties which are `Comparable` (such as `Integer`, `String` or `Duration`),
  
positive.code: [[constraintStreamsDealingWithDuplicateTuplesUsingDistinct]]
  ==== Dealing with duplicate tuples using `distinct()`
  
  As a general rule, tuples in constraint streams will be distinct.
  That is, no two tuples that equal one another.
  However, certain operations such as <<constraintStreamsMappingTuples,tuple mapping>> may produce constraint streams
  where that is not true.
  
negative.code: [[constraintStreamsImplementations]]
  == Variant implementation types
  
  Constraint streams come in two flavors:
  
  * *CS Drools* (default): a fast, feature-complete implementation that uses Drools underneath.
  
  * *Bavet*: a fast, experimental implementation.
  It lacks features and therefore many of the <<examplesOverview,examples>> are not supported.
  To try it out set the `constraintStreamImplType` to `BAVET` in your solver config:
  +
  [source,xml,options="nowrap"]
  ----
      <solver xmlns="https://www.optaplanner.org/xsd/solver" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="https://www.optaplanner.org/xsd/solver https://www.optaplanner.org/xsd/solver/solver.xsd">
        <scoreDirectorFactory>
          <!-- BAVET is experimental -->
          <constraintStreamImplType>BAVET</constraintStreamImplType>
          <constraintProviderClass>com.example.MyConstraintProvider</constraintProviderClass>
        </scoreDirectorFactory>
        ...
      </solver>
  ----
  
  Both of these variants implement the same `ConstraintProvider` API.
  No Java code changes are necessary to switch between the two.
  