anchor.diff:  Notes:
   
   * While the example above supplied no constructor, you can also supply a no-arg constructor
  -or a constructor with a single `Map` argument as previously mentioned.
  +or a constructor where the first argument is a `Map`, most typically it's the only argument.
  +* When no (or a no-arg) constructor is declared, Groovy replaces the named constructor call by a call
  +to the no-arg constructor followed by calls to the setter for each supplied named property.
  +* When the first argument is a Map, Groovy combines all named parameters into a Map (regardless of ordering)
  +and supplies the map as the first parameter. This can be a good approach if your properties are declared as
  +`final` (since they will be set in the constructor rather than after the fact with setters).
   * You can support both named and positional construction
   by supply both positional constructors as well as a no-arg or Map constructor.
  -* When no (or a no-arg) constructor is declared, Groovy replaces the named constructor call by a call
  -to the no-arg constructor followed by calls to the setter for each supplied named property. So, you
  -might be better off using the Map constructor if your properties are declared as `final` (since they
  -must be set in the constructor rather than after the fact with setters).
  -
  +* You can support hybrid construction by having a constructor where the first argument
  +is a Map but there are also additional positional parameters. Use this style with caution.
   
   === Methods
   
  
positive.code: Constructors are special methods used to initialize an object with a specific state. As with normal methods,
  it is possible for a class to declare more than one constructor, so long as each constructor has a unique
  type signature. If an object doesn't require any parameters during construction, it may use a _no-arg_ constructor.
  If no constructors are supplied, an empty no-arg constructor will be provided by the Groovy compiler. For constructors
  with parameters, Groovy supports two invocation styles: using positional parameters or named parameters.
  The former style is similar to how you would use Java constructors, while the second way
  allows one to specify parameter names when invoking the constructor.
  
  ==== Positional argument constructor
  
  To create an object by using positional argument constructors, the respective class needs to declare one or more
  constructors. In the case of multiple constructors, each must have a unique type signature. The constructors can also
  added to the class using the gapi:groovy.transform.TupleConstructor[] annotation.
  
  Typically, once at least one constructor is declared, the class can only be instantiated by having one of its
  constructors called. It is worth noting that, in this case, you can't normally create the class with named parameters.
  Groovy does support named parameters so long as the class contains a no-arg constructor or a constructor which takes
  a single `Map` argument - see the next section for details.
  
  There are three forms of using a declared constructor. The first one is the normal Java way, with the `new` keyword.
  The others rely on coercion of lists into the desired types. In this case, it is possible to coerce with the `as`
  
negative.code: <3> Constructor usage, using coercion with `as` keyword
  <4> Constructor usage, using coercion in assignment
  
  ==== Named parameters
  
  If no (or a no-arg) constructor is declared, it is possible to create objects by passing parameters in the form of a
  map (property/value pairs). This can be in handy in cases where one wants to allow several combinations of parameters.
  Otherwise, by using traditional positional parameters it would be necessary to declare all possible constructors.
  Having a constructor where the first (and perhaps only) argument is a `Map` argument is also supported - such a
  constructor may also be added using the gapi:groovy.transform.MapConstructor[] annotation.
  
  [source,groovy]
  ----
  