anchor.diff:  <4> `age` parameter given in the instantiation
   <5> `name` and `age` parameters given in the instantiation
   
  -It is important to highlight, however, that this approach gives more power to the constructor caller, while imposes a major responsibility to it. Thus, if a restriction is needed, one can just declare one or more constructors, and the instantiation by named parameters will no longer be available.
  +It is important to highlight, however, that this approach gives more power to the constructor caller,
  +while imposing an increased responsibility on the caller to get the names and value types correct.
  +Thus, if greater control is desired, declaring constructors using positional parameters might be preferred.
  +
  +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.
  +* 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 propertie are declared as `final` (since they
  +must be set in the constructor rather than after the fact with setters).
   
   
   === Methods
  
positive.code: 
  === Constructors
  
  Constructors are special methods used to initialize an object with a specific state. As in normal methods, it is possible for a class to declare more than one constructor. In Groovy there are two ways to invoke constructors: with positional parameters or named parameters. The former one is like we invoke Java constructors, while the second way allows one to specify the parameter names when invoking the constructor.
  
  ==== Positional argument constructor
  
  To create an object by using positional argument constructors, the respective class needs to declare each of the constructors it allows being called. A side effect of this is that, once at least one constructor is declared, the class can only be instantiated by getting one of its constructors called. It is worth noting that, in this case, there is no way to create the class with named parameters.
  
  There is 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` keyword and by statically typing the variable.
  
  [source,groovy]
  ----
  
negative.code: 
  ==== 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]
  ----
  