Specialized methods for a generic class based on type argument

[Swaranga Sarma]

>More like "Add generics to Java".

Ouch! :-)

Thank you for the responses.

Regards
Swaranga


On Mon, May 9, 2022 at 6:53 AM Brian Goetz <brian.goetz at oracle.com> wrote:

> What you are suggesting is what we call a _conditional method_; a method
> that is a member of some parameterizations but not others.  This is an
> entirely reasonable concept, and we've given extensive thought to the topic
> under Project Valhalla, but there are a number of challenges that mean such
> things are at least a few steps away:
>
>  - It is not merely enough to say that sum() is only a member of List<T>
> for certain T; as your example shows, you would like to be able to get at
> the zero value for T, and its addition function.  (More specifically, sum()
> works when T is a *monoid*, and the implementation of sum() requires access
> to a *witness* to it's monoid-hood.)
>
>  - Said witnessing requires some degree of runtime reification, either in
> the form of direct reification of generic type parameters (as C# does), or
> the use of implicit arguments (as Scala does.)
>
>  - As your example suggests, even if you had the above, you probably would
> soon be wondering/asking/complaining "why can't I say `+`, rather than
> calling `add`", so in addition to asking for reified generics and witnesses
> to type classes, you are also asking for operator overloading.
>
> None of the above are out of the question, but each are obviously a
> significant lift, so don't expect it to fall out as an "Amber-sized"
> feature.  More like "Add generics to Java".
>
>
>
> On 5/9/2022 1:44 AM, Swaranga Sarma wrote:
>
> Apologies if this is not the right mailing list; I did not find a dedicated
> mailing list for generics and Amber deals with language level improvements
> hence posting it here.
>
> I want to be able to write specialized methods based on the type argument
> for my generic class. Using the List interface as an example:
>
> interface List<T> {
>    _if_T_instanceof_Number Number sum() {
>       T sum = 0;
>       for (T t : this) {
>         sum += t;
>       }
>       return sum;
>    }
> }
>
> The above method can be called only if the list instance is of type List<?
> extends Number> and if the reference type is of raw type then these methods
> should not be visible at the call site. There are other compatibility
> concerns like what if a subinterface or an implementing class defines these
> methods but I am of course leaving these to the experts to deal with. ;-)
>
> Is this something that might be possible in the future?
>
> Regards
> Swaranga
>
>
>