Prevent Type Naming Conflict when Using @Future

[dwtj]

Consider the executable capsule program seen below.

It uses an @Future procedure. When a compilation unit both declares an @Future procedure and also uses an @Future procedure, that compilation unit will likely need to use two types both named Future

• java.util.concurrent.Future
• org.paninij.lang.Future

However, because both of these types are named future, they cannot both be imported. Thus, the author of the code needs to decide which of these two types they need to fully qualify. (In the are fully qualified.)

This is rather awkward, and is likely to be confusing to some programmers.

We should probably rename @Future to prevent this common understandable naming conflict. (Alternatively, we could choose to use our own future type, something other than java.util.concurrent.Future, but I prefer the former.) Unless I am mistaken, I think that we can't use a type as both an annotation and a "normal" Java interface type.

package issue;

import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import org.paninij.lang.Capsule;
import org.paninij.lang.CapsuleSystem;
import org.paninij.lang.Local;
import org.paninij.lang.Root;

public class Main {
    public static void main(String[] args) {
        CapsuleSystem.start(Client.class, args);
    }
}
@Capsule class SquarerCore {
  @org.paninij.lang.Future
  int[] getSquares(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
       arr[i] = arr[i]*arr[i];
    }
    return arr;
  }
}

@Root @Capsule
class ClientCore {
  @Local Squarer s;
  void run() {
    Future<int[]> f = s.getSquares(new int[] {1, 2, 3, 4, 5});
    try {
        int[] arr = f.get();
        System.out.println(Arrays.toString(arr));
    } catch (InterruptedException | ExecutionException e) {
        throw new RuntimeException(e);
    }
  }
}