anchor.diff:  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
  +If no constructors are supplied, an empty no-arg constructor will be provided by the Groovy compiler.
  +
  +Groovy supports two invocation styles:
  +
  +* _positional parameters_ are used in a similar to how you would use Java constructors
  +* _named parameters_ allow you to specify parameter names when invoking the constructor.
  +
  +==== Positional parameters
  +
  +To create an object by using positional parameters, 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.
  +Groovy does support named parameters so long as the class contains a no-arg constructor or provides a constructor which
  +takes a `Map` argument as the first (and potentially only) 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`
  
positive.code: <1> Method call with additional `number` argument of `Integer` type
  <2> Method call with changed order of arguments
  
  WARNING: Groovy allows floating named arguments around and pass them after regular argument(s) when invoking the method.
  However, it still expects that `Map` argument that represents named arguments is defined as the first argument of the method.
  
  If we break the rule mentioned earlier and we swap method arguments, so `Map` gets defined as the second (or later) argument, we will start
  seeing `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 named arguments represented as `Map` parameter are not defined as the first argument
  
  Above exception can be avoided if we replace named arguments with an explicit `Map` argument:
  
  
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]
  ----
  