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: <3> Constructor usage, using coercion with `as` keyword
  <4> Constructor usage, using coercion in assignment
  
  
  ==== Named argument constructor
  
  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 taking a single `Map` argument is also supported - such a constructor may also be added using
  the gapi:groovy.transform.MapConstructor[] annotation.
  
  [source,groovy]
  ----
  
negative.code: <1> Method call with additional `number` argument of `Integer` type
  <2> Method call with changed order of arguments
  
  
  If we don't have the Map as the first argument, then a Map must be supplied for that argument instead of named parameters.
  Failure to do so will lead to `groovy.lang.MissingMethodException`:
  
  [source,groovy]
  ----
  include::{projectdir}/src/spec/test/objectorientation/MethodsTest.groovy[tags=failed_named_arguments_with_additional_arguments ,indent=0]
  ----
  <1> Method call throws `groovy.lang.MissingMethodException: No signature of method: foo() is applicable for argument types: (LinkedHashMap, Integer) values: [[name:Marie, age:1], 23]`, because the named argument `Map` parameter is not defined as the first argument
  
  Above exception can be avoided if we replace named arguments with an explicit `Map` argument:
  
  