anchor.diff:  <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`:
  +
  +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 named arguments represented as `Map` parameter are not defined as the first argument
  +<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:
   
  
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: ----
  <1> Explicit `Map` argument in place of named arguments makes invocation valid
  
  TIP: Although Groovy allows you to mix named and positional parameters, it can lead to unnecessary confusion.
  Mix named and positional arguments with caution.
  
  ==== Default arguments
  
  