Make @This work on type parameters

Manifold version: 0.45-alpha JDK version: 11.0.2

Example of requested feature:

package utilities.extensions.java.lang.Object;

import manifold.ext.api.Extension;
import manifold.ext.api.This;

import java.util.function.Function;

@Extension
public class MyObjectExt {

    public static <T extends Object, R> R let1(@This Object thiz, Function<T, R> mapper) {
        return mapper.apply((T) thiz);
    }

    // Cannot compile, Type of thiz must be Object. **Please make this work**
    public static <T extends Object, R> R let2(@This T thiz, Function<T, R> mapper) {
        return mapper.apply((T) thiz);
    }

    public static <T extends Object, R> R let3(T thiz, Function<T, R> mapper) {
        return mapper.apply((T) thiz);
    }
    
    public static void test() {
        String str = "abc";
        String x11 = str.let1((String it) -> it.trim());     // This is ok, but I have to specify type of 'it'
        Object x12 = str.let1(it -> it.trim());            // Error, type of 'it' is deduced as Object

        String x21 = str.let2(it -> it.trim());            // Ideal state, type of 'it' should be deduced as String, if method let2 works
        
        String x31 = let3(str, it -> it.trim());        // without extension method, it's type deduction is working
    }
}

When I call method let1 with argument of some type T, it’s type info is lost in method body, so type parameter T of mapper cannot get its correct type. In my eyes extension method is just syntax sugar, so if let3 is working, so should let1.

[rsmckinney]

Hi @WilliamStone.

The functionality you’re looking for is best expressed in terms of the self type. With the latest alpha release (0.47-alpha), Manifold now fully supports the self type via @Self.

Your example modified to use @Self:

@Extension
public class MyObjectExt {
    public static <R> R let(@This Object thiz, Function<@Self Object, R> mapper) {
        return mapper.apply(thiz);
    }
}

String str = "abc";
String result = str.let(s -> s.trim());

Use the self type to express the type of the invoker (aka the type of this). Use it in super classes and extension methods anywhere in a method signature or field type. It is especially useful as a means to simplify architecture that otherwise involves recursive generic types. Other applications involve extension methods and structural interfaces.

Note the accompanying v0.47-alpha IntelliJ plugin is awaiting JetBrains approval, which can take a couple of days.

[WilliamStone]

Thanks! I understand that the extension class is for Object not generic type T. I still feels a little inconvenience that if the actuaI type is some class extending Object, I cannot refer to its type by defining a generic type T extending Object, instead I have to regard it as Object itself. No big difference till now, and I’ll try to get to it.