groovy

Support true optional parameters.

Details

  • Type: New Feature New Feature
  • Status: Open Open
  • Priority: Major Major
  • Resolution: Unresolved
  • Affects Version/s: 1.6.2
  • Fix Version/s: None
  • Component/s: None
  • Labels:
    None
  • Testcase included:
    yes
  • Number of attachments :
    0

Description

Currently, there is no way of calling a method with sparse optional parameters that are not sequential with respect to the order in which the parameters are declared.

Python offers this flexibility, and it makes sense that Groovy allow it, too. When implemented, the following would be expected to pass:

public def foo(int a, int b = 42, int c = 314)
{
    return [a, b, c]
}

// the following two cases pass, atm.
assert foo(1) == [1, 42, 314]
assert foo(1, 2) == [1, 2, 314]
// the following three cases fail, atm.
assert foo(1, b: 2) == [1, 2, 314]
assert foo(1, c: 3) == [1, 42, 3]
assert foo(1, b: 2, c: 3) == [1, 2, 3]

Activity

Ascending order - Click to sort in descending order
Hide
Permalink
Peter Niederwieser added a comment -

It seems this would require true named parameters in the first place, a feature which Groovy doesn't have at the moment.

Show
Peter Niederwieser added a comment - It seems this would require true named parameters in the first place, a feature which Groovy doesn't have at the moment.
Hide
Permalink
Russel Winder added a comment - - edited

Python parameter passing mechanism is rather good isn't it

Isn't the workaround in Groovy to use a Map parameter and overloading:

public def foo ( Map params ) {
  final Map values = [ a : 1 , b : 42 , c : 314 ]
  params.each { k , v -> values[k] = v }
  return [ values.a , values.b , values.c ]
}
public def foo ( int a ) { foo ( a : a ) }
public def foo ( Map m , int a ) { m.a = a ; foo ( m ) }
public def foo ( int a , int b ) { foo ( a : a , b : b ) }
public def foo ( Map m , int a , int b ) { m.a = a ; m.b = b ; foo ( m ) }
public def foo ( int a , int b , int c ) { foo ( a : a , b : b , c : c ) }

try {
  foo ( )
  /* Should not get here */
  throw new RuntimeException ( "Aaaaarrrrggggghhhhh...." )
}
catch (  org.codehaus.groovy.runtime.metaclass.MethodSelectionException mse ) { /* fails as it should. */ }

assert foo ( 1 ) == [ 1 , 42 , 314 ]
assert foo ( 1 , 2 ) == [ 1 , 2 , 314 ]
assert foo ( 1 , b : 2 ) == [ 1 , 2 , 314 ]
assert foo ( 1 , c : 3 ) == [ 1 , 42 , 3 ]
assert foo ( 1 , b : 2 , c : 3 ) == [ 1 , 2 , 3 ]

Perhaps this needs reifying. Perhaps a GEP should be raised?

Show
Russel Winder added a comment - - edited Python parameter passing mechanism is rather good isn't it Isn't the workaround in Groovy to use a Map parameter and overloading: public def foo ( Map params ) { final Map values = [ a : 1 , b : 42 , c : 314 ] params.each { k , v -> values[k] = v } return [ values.a , values.b , values.c ] } public def foo ( int a ) { foo ( a : a ) } public def foo ( Map m , int a ) { m.a = a ; foo ( m ) } public def foo ( int a , int b ) { foo ( a : a , b : b ) } public def foo ( Map m , int a , int b ) { m.a = a ; m.b = b ; foo ( m ) } public def foo ( int a , int b , int c ) { foo ( a : a , b : b , c : c ) } try { foo ( ) /* Should not get here */ throw new RuntimeException ( "Aaaaarrrrggggghhhhh...." ) } catch ( org.codehaus.groovy.runtime.metaclass.MethodSelectionException mse ) { /* fails as it should. */ } assert foo ( 1 ) == [ 1 , 42 , 314 ] assert foo ( 1 , 2 ) == [ 1 , 2 , 314 ] assert foo ( 1 , b : 2 ) == [ 1 , 2 , 314 ] assert foo ( 1 , c : 3 ) == [ 1 , 42 , 3 ] assert foo ( 1 , b : 2 , c : 3 ) == [ 1 , 2 , 3 ] Perhaps this needs reifying. Perhaps a GEP should be raised?
Hide
Permalink
Paul King added a comment -

I guess we need to decide whether we want to support named params natively first but if not, we could implement an AST transform. Javadoc for such a transform might look something like below:

/**
 * Method annotation used to provide an overloaded map version of a method suitable
 * for use with Groovy named-argument method calling.
 *
 * As an example, suppose a class contains the following two methods:
 * <pre>
 * {@code @NamedArgs}
 * Integer plus(Integer x, Integer y = 1) {
 *     x + y
 * }
 * {@code @NamedArgs}
 * String plus(String a, String b) {
 *     a + b
 * }
 * </pre>
 * This will result in the following additional method being added transparently to the class:
 * <pre>
 * def plus(Map m) {
 *     if (m.x && m.x instanceof Integer && (!m.contains('y') || m.y instanceof Integer)) {
 *         return (Integer) plus((Integer)m.x, (Integer)(m.contains('y') ? m.y : 1))
 *     }
 *     if (m.a && m.a instanceof String && m.b && m.b instanceof String)) {
 *         return (String) plus((String)m.a, (String)m.b)
 *     }
 *     throw new MissingMethodException()
 * }
 * </pre>
 * which could be called using any of these forms:
 * <pre>
 * assert plus(5) == 6
 * assert plus(1, 2) == 3
 * assert plus(x:10) == 11
 * assert plus(x:10, y:20) == 30
 * assert plus('foo', 'bar') == 'foobar'
 * assert plus(a:'foo', b:'bar') == 'foobar'
 * </pre>
 *
 * @since 1.9.0
 */
Show
Paul King added a comment - I guess we need to decide whether we want to support named params natively first but if not, we could implement an AST transform. Javadoc for such a transform might look something like below: /** * Method annotation used to provide an overloaded map version of a method suitable * for use with Groovy named-argument method calling. * * As an example, suppose a class contains the following two methods: * <pre> * {@code @NamedArgs} * Integer plus( Integer x, Integer y = 1) { * x + y * } * {@code @NamedArgs} * String plus( String a, String b) { * a + b * } * </pre> * This will result in the following additional method being added transparently to the class: * <pre> * def plus(Map m) { * if (m.x && m.x instanceof Integer && (!m.contains('y') || m.y instanceof Integer )) { * return ( Integer ) plus(( Integer )m.x, ( Integer )(m.contains('y') ? m.y : 1)) * } * if (m.a && m.a instanceof String && m.b && m.b instanceof String )) { * return ( String ) plus(( String )m.a, ( String )m.b) * } * throw new MissingMethodException() * } * </pre> * which could be called using any of these forms: * <pre> * assert plus(5) == 6 * assert plus(1, 2) == 3 * assert plus(x:10) == 11 * assert plus(x:10, y:20) == 30 * assert plus('foo', 'bar') == 'foobar' * assert plus(a:'foo', b:'bar') == 'foobar' * </pre> * * @since 1.9.0 */

People

  • Assignee:
    Unassigned
    Reporter:
    Suk-Hyun Cho
Vote (4)
Watch (5)

Dates

  • Created:
    Updated: