Function parameter order

[Raab, Donald]

Using Type a 3 parameter function would read as follows using the "of" and "to" additives:

Function.OfType3ToResult<Type1, Type2, Type3, Result>

Someone might ask "What is a function of Type3".  This might read more naturally and explicitly.

Function.With3ObjectParametersReturningResult<Type1, Type2, Type3, Result>   // This might read nicely and is very explicit but gives me no real value having to read all that - it might be useful to someone brand new day one, but then would just be annoying after they understand the structure

Readability is very subjective.  We've had loads of internal discussions over the readability of "of" vs. "with" vs. "from".  Take the prepositions away and the arguments usually go away, and productive work resumes.

This is how I wound up at the bare essentials of what I feel is important.   What type do I need (Predicate, Procedure, Function or PrimitiveFunction), how many parameters are in the function, what are their types and what is the return type if it is an Object Function?

Funtion.T3<T1, T2, T3, R> is brief and gets to the point I care about.

Funtion.Type3<Type1, Type2, Type3, Result>  // is better or is this worse?
{(Type1, Type2, Type3) -> Result}  // What about the function type equivalent (assuming syntax is reasonable here)?
{(T1, T2, T3) -> R}  // Better or worse?
{(A, B, C) -> R}  // Now?

Consider a complex block that we would never likely need but could support without line wrapping using the type compression approach.

Function.T3Int4FloatDoubleT2<T1, T2, T3, T4 T5, Result>

This would wind up with 11 parameters in the method signature.

It would look something like this using a function type.

{(T1, T2, T3, int, int, int, int, float, double, T4, T5) -> Result}

On the Function.OfType2ToInt example, this is the intent of having a separate IntFunction.  IntFunction returns int where Function returns a generic Result.  So using your example, I would have written it as follows in this proposal:

IntFunction.T2

Breaking the primitives into separate parent types in this way gives a more human friendly grouping and should be easy to find.  Alternatively you could say FunctionToInt.  Either way is more consistent with Predicate, Procedure and Function which all indicate their return type (boolean, void and Object).

From: tpeierls at gmail.com [mailto:tpeierls at gmail.com] On Behalf Of Tim Peierls
Sent: Wednesday, November 07, 2012 12:32 PM
To: Raab, Donald [Tech]
Cc: Brian Goetz; lambda-libs-spec-experts at openjdk.java.net
Subject: Re: Function parameter order

On Wed, Nov 7, 2012 at 12:18 PM, Raab, Donald <Donald.Raab at gs.com<mailto:Donald.Raab at gs.com>> wrote:
Here is a test I wrote that shows all of the useful combinations I can think of in a few hours time (there are more of course).  It should show how these things will look better than me trying to use some formal specification.  I know some folks hate numeric arity, but I think it is a form of useful compression (how many Objects are in ObjectObjectObjectObjectObject or TTTTT vs. just saying Object5 or T5).  If you don't like "T" here please replace it with "Object" or your favorite generified type name.

Numbers are fine here. T isn't terrible. What about just "Type"?


I've included 3 tests below.  One for Procedure, Function and IntFunction.  Predicate will be like Procedure (only one class) so I didn't include it, although technically, it could be handled with a BooleanFunction.  I prefer Predicate, but I wonder whether both BooleanFunction and Predicate are useful.

It's important to have Predicate. Question is whether there's any use for BooleanFunction other than completeness.



I will assume if you can't reason about it without asking lots of questions, then it is not a good proposal.

I got it reasonably quickly, so I think it's a reasonable proposal.


Return type is the last parameter in the list of generic types in the case of Function, so hopefully that explains one little thing that might be hard to figure out with all Strings in the examples.

I could live with this but would find it easier to read if there were little words to delimit and clarify things for casual readers, e.g., Function.OfType2ToInt.

--tim