anchor.diff:  ==== Examples
   
   * Applying a constraint to the value wrapped by a container type:
  -
  ++
   [source,java]
   ----
   Property<@Min(1) Integer> value;
   ----
  -
  ++
   Note that `@Valid` is not required; the `@Min` constraint will be validated when the `value` property is subject to validation.
   
  -* Applying a constraint to each value in a collection type:
  -
  +* Applying constraints to each value in a collection type:
  ++
   [source,java]
   ----
   List<@NotNull @Email String> emails;
   ----
   
   * Cascaded validation of the values in a collection type:
  -
  ++
   [source,java]
   ----
   List<@Valid Order> orders;
   ----
  -
  ++
   This will validate the constraints on each `Order` element in the list.
   
   * The legacy style for cascaded validation is supported as well:
  -
  ++
   [source,java]
   ----
   @Valid List<Order> orders;
   ----
  -
  ++
   This would also validate any constraints on a custom list type (e.g. `MyList#getId()`).
   TODO: we never clarified that in 1.1. Should it be made explicit?
   
   * Map validation with type argument constraints and cascading:
  -
  ++
   [source,java]
   ----
   @Valid
   Map<@RegExp(...) String, @RetailOrder Order> orders;
   ----
  -
  ++
   This would validate the map's keys against `@RegExp`, the map's values against `@RetailOrder` and apply cascaded validation of the map values (as well as the map object itself).
   
   * When selecting extractors, type parameters must be throroughly traced in the hierarchy.
   Consider this case where the order of the type parameters of `Map` is swapped in a sub-type:
  -
  ++
   [source,java]
   ----
   public class CrazyMap<K, V> implements Map<V, K> { ... }
   ----
  -
  ++
   [source,java]
   ----
   public class Example {
       private CrazyMap<@RegExp(...) String, @Min(0) Long> crazyMap = ...;
   }
   ----
  -
  ++
   Assuming there is no dedicated extractor for `CrazyMap` but only the default ones for `K` and `V` of `Map`,
   extraction for `@RegExp` must happen via the default map value extractor and extraction for `@Min` via the default map key extractor.
  -
  ++
   A type parameter in a sub-type may also map to several type parameters in a super-type:
  -
  ++
   [source,java]
   ----
   interface NumericMap<T extends Number> extends Map<T, T> {}
   ----
  -
  ++
   [source,java]
   ----
   private NumericMap<@Min(1) Integer> integerMap;
   ----
  -
  ++
   The `@Min` constraint is to be applied to the map's keys and values as the annotated type parameter maps to `K` and `V` of `Map`.
   
   * type argument constraints can be applied to the elements of `Object` arrays and arrays of any primitive type:
  -
  ++
   [source,java]
   ----
   String @Email[] emails;
   ----
  -
  ++
   [source,java]
   ----
   int @Min(1) [] positiveNumbers;
   ----
   
   * The extractor for cascaded validation is determined based on an element's runtime type:
  -
  ++
   [source,java]
   ----
   Collection<@Valid Order> orders = new ArrayList<>();
   ----
  -
  ++
   Here the most-specific extractor for the runtime type `ArrayList` must be applied, causing the property nodes of violations to have an index set (`Node#getIndex()`).
   
   * The container value passed to a value extractor is retrieved from the element that has the type argument carrying the constraint or `@Valid` annotation:
  -
  ++
   [source,java]
   ----
   private Map<String, @Valid @RetailOrder Order> ordersByName;
  
positive.code: }
  ----
  
  If this extractor was the single most-specific extractor for `StringProperty`, the `@Email` constraint above would automatically be applied to the wrapped string value.
  
  In rare cases it may happen that a constraint should be applied to the wrapped value although an extractor exists.
  In this case the `ConstraintsApplyTo` annotation can be given on the element itself to prevent the unwrapping:
  
negative.code: the map as obtained directly from the field will be passed to the map value extractor in order to obtain the map values.
  
  * Custom extractor for a `Tuple` type:
  +
  [source,java]
  ----
  public interface Tuple<T1, T2> {
  