Allows construction of a named-arg equivalent method or constructor. The method or constructor will have at least a first argument of type Map and may have more arguments. As such, it can be called using Groovy's named-arg syntax. The original method/constructor is retained and is called by the generated method/constructor. One benefit of this approach is the potential for improved type checking. The annotated "tuple" method/constructor can be type rich and will be checked as such during normal compilation. The generated method/constructor using the map argument will be named-argument friendly but the map also hides type information. The generated method however contains no business logic so the chance of errors is minimal. Any arguments identified as named arguments will be supplied as part of the map. Any additional arguments are supplied in the normal tuple style. Named arguments are identified in one of three ways:

1. Use one or more @NamedParam annotations to explicitly identify such arguments
2. Use one or more @NamedDelegate annotations to explicitly identify such arguments as delegate arguments
3. If no arguments with @NamedParam or @NamedDelegate annotations are found the first argument is assumed to be an implicit named delegate

 import groovy.transform.*

 @ToString(includeNames=true, includeFields=true)
 class Color {
     Integer r, g, b
 }

 @NamedVariant
 String foo(Color shade) {
     shade
 }

 def result = foo(g: 12, b: 42, r: 12)
 assert result.toString() == 'Color(r:12, g:12, b:42)'
 

 String foo(Map args) {
     return foo(args as Color)
 }
 

See Also:

VisibilityOptions

NamedParam

NamedDelegate

Since:

2.5.0