[Java] Rename java ObjectRef/ActorHandle (#8799)

java/api/src/main/java/io/ray/api/ActorCall.java

@@ -21,634 +21,634 @@ import io.ray.api.function.RayFuncVoid6;
 @SuppressWarnings({"rawtypes", "unchecked"})
 interface ActorCall<A> {
 
-  default <R> RayObject<R> call(RayFunc1<A, R> f) {
+  default <R> ObjectRef<R> call(RayFunc1<A, R> f) {
     Object[] args = new Object[]{};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
   default void call(RayFuncVoid1<A> f) {
     Object[] args = new Object[]{};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, R> RayObject<R> call(RayFunc2<A, T0, R> f, T0 t0) {
+  default <T0, R> ObjectRef<R> call(RayFunc2<A, T0, R> f, T0 t0) {
     Object[] args = new Object[]{t0};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, R> RayObject<R> call(RayFunc2<A, T0, R> f, RayObject<T0> t0) {
+  default <T0, R> ObjectRef<R> call(RayFunc2<A, T0, R> f, ObjectRef<T0> t0) {
     Object[] args = new Object[]{t0};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
   default <T0> void call(RayFuncVoid2<A, T0> f, T0 t0) {
     Object[] args = new Object[]{t0};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0> void call(RayFuncVoid2<A, T0> f, RayObject<T0> t0) {
+  default <T0> void call(RayFuncVoid2<A, T0> f, ObjectRef<T0> t0) {
     Object[] args = new Object[]{t0};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, T0 t0, T1 t1) {
+  default <T0, T1, R> ObjectRef<R> call(RayFunc3<A, T0, T1, R> f, T0 t0, T1 t1) {
     Object[] args = new Object[]{t0, t1};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, T0 t0, RayObject<T1> t1) {
+  default <T0, T1, R> ObjectRef<R> call(RayFunc3<A, T0, T1, R> f, T0 t0, ObjectRef<T1> t1) {
     Object[] args = new Object[]{t0, t1};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, RayObject<T0> t0, T1 t1) {
+  default <T0, T1, R> ObjectRef<R> call(RayFunc3<A, T0, T1, R> f, ObjectRef<T0> t0, T1 t1) {
     Object[] args = new Object[]{t0, t1};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, R> RayObject<R> call(RayFunc3<A, T0, T1, R> f, RayObject<T0> t0, RayObject<T1> t1) {
+  default <T0, T1, R> ObjectRef<R> call(RayFunc3<A, T0, T1, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1) {
     Object[] args = new Object[]{t0, t1};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
   default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, T0 t0, T1 t1) {
     Object[] args = new Object[]{t0, t1};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, T0 t0, RayObject<T1> t1) {
+  default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, T0 t0, ObjectRef<T1> t1) {
     Object[] args = new Object[]{t0, t1};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, RayObject<T0> t0, T1 t1) {
+  default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, ObjectRef<T0> t0, T1 t1) {
     Object[] args = new Object[]{t0, t1};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, RayObject<T0> t0, RayObject<T1> t1) {
+  default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, ObjectRef<T0> t0, ObjectRef<T1> t1) {
     Object[] args = new Object[]{t0, t1};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, T1 t1, T2 t2) {
+  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, T1 t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, T1 t1, RayObject<T2> t2) {
+  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, T1 t1, ObjectRef<T2> t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, RayObject<T1> t1, T2 t2) {
+  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, ObjectRef<T1> t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2) {
+  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayObject<T0> t0, T1 t1, T2 t2) {
+  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, ObjectRef<T0> t0, T1 t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2) {
+  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2) {
+  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> RayObject<R> call(RayFunc4<A, T0, T1, T2, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2) {
+  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
   default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, T1 t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, T1 t1, RayObject<T2> t2) {
+  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, T1 t1, ObjectRef<T2> t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, RayObject<T1> t1, T2 t2) {
+  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, ObjectRef<T1> t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2) {
+  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayObject<T0> t0, T1 t1, T2 t2) {
+  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, T1 t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2) {
+  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2) {
+  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2) {
+  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, T2 t2, T3 t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, T2 t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, R> RayObject<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3, R> ObjectRef<R> call(RayFunc5<A, T0, T1, T2, T3, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
   default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, T2 t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3) {
+  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
     Object[] args = new Object[]{t0, t1, t2, t3};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4, R> RayObject<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4, R> ObjectRef<R> call(RayFunc6<A, T0, T1, T2, T3, T4, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    return Ray.internal().callActor((RayActor) this, f, args);
+    return Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
   default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, T2 t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, T1 t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, T2 t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, T3 t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, T4 t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, RayObject<T0> t0, RayObject<T1> t1, RayObject<T2> t2, RayObject<T3> t3, RayObject<T4> t4) {
+  default <T0, T1, T2, T3, T4> void call(RayFuncVoid6<A, T0, T1, T2, T3, T4> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2, ObjectRef<T3> t3, ObjectRef<T4> t4) {
     Object[] args = new Object[]{t0, t1, t2, t3, t4};
-    Ray.internal().callActor((RayActor) this, f, args);
+    Ray.internal().callActor((ActorHandle) this, f, args);
   }
 
 }

java/api/src/main/java/io/ray/api/ActorHandle.java

@@ -12,9 +12,9 @@ package io.ray.api;
  *   }
  * }
  * // Create an actor, and get a handle.
- * RayActor<MyActor> myActor = Ray.createActor(MyActor::new);
+ * ActorHandle<MyActor> myActor = Ray.createActor(MyActor::new);
  * // Call the `echo` method remotely.
- * RayObject<Integer> result = myActor.call(MyActor::echo, 1);
+ * ObjectRef<Integer> result = myActor.call(MyActor::echo, 1);
  * // Get the result of the remote `echo` method.
  * Assert.assertEqual(result.get(), 1);
  * }</pre>
@@ -24,6 +24,6 @@ package io.ray.api;
  *
  * @param <A> The type of the concrete actor class.
  */
-public interface RayActor<A> extends BaseActor, ActorCall<A> {
+public interface ActorHandle<A> extends BaseActorHandle, ActorCall<A> {
 
 }

java/api/src/main/java/io/ray/api/BaseActorHandle.java

@@ -7,7 +7,7 @@ import io.ray.api.id.ActorId;
  *
  * A handle can be used to invoke a remote actor method.
  */
-public interface BaseActor {
+public interface BaseActorHandle {
 
   /**
    * @return The id of this actor.

java/api/src/main/java/io/ray/api/ObjectRef.java

@@ -3,10 +3,10 @@ package io.ray.api;
 import io.ray.api.id.ObjectId;
 
 /**
- * Represents an object in the object store.
+ * Represents a reference to an object in the object store.
  * @param <T> The object type.
  */
-public interface RayObject<T> {
+public interface ObjectRef<T> {
 
   /**
    * Fetch the object from the object store, this method will block

java/api/src/main/java/io/ray/api/PyActorCall.java

@@ -10,34 +10,34 @@ import io.ray.api.function.PyActorMethod;
 @SuppressWarnings({"rawtypes", "unchecked"})
 interface PyActorCall {
 
-  default <R> RayObject<R> call(PyActorMethod<R> pyActorMethod) {
+  default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod) {
     Object[] args = new Object[]{};
-    return Ray.internal().callActor((RayPyActor)this, pyActorMethod, args);
+    return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
   }
 
-  default <R> RayObject<R> call(PyActorMethod<R> pyActorMethod, Object obj0) {
+  default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0) {
     Object[] args = new Object[]{obj0};
-    return Ray.internal().callActor((RayPyActor)this, pyActorMethod, args);
+    return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
   }
 
-  default <R> RayObject<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1) {
+  default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1) {
     Object[] args = new Object[]{obj0, obj1};
-    return Ray.internal().callActor((RayPyActor)this, pyActorMethod, args);
+    return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
   }
 
-  default <R> RayObject<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2) {
+  default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2) {
     Object[] args = new Object[]{obj0, obj1, obj2};
-    return Ray.internal().callActor((RayPyActor)this, pyActorMethod, args);
+    return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
   }
 
-  default <R> RayObject<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2, Object obj3) {
+  default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2, Object obj3) {
     Object[] args = new Object[]{obj0, obj1, obj2, obj3};
-    return Ray.internal().callActor((RayPyActor)this, pyActorMethod, args);
+    return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
   }
 
-  default <R> RayObject<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4) {
+  default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4) {
     Object[] args = new Object[]{obj0, obj1, obj2, obj3, obj4};
-    return Ray.internal().callActor((RayPyActor)this, pyActorMethod, args);
+    return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
   }
 
 }

java/api/src/main/java/io/ray/api/PyActorHandle.java

@@ -3,7 +3,7 @@ package io.ray.api;
 /**
  * Handle of a Python actor.
  */
-public interface RayPyActor extends BaseActor, PyActorCall {
+public interface PyActorHandle extends BaseActorHandle, PyActorCall {
 
   /**
    * @return Module name of the Python actor class.

java/api/src/main/java/io/ray/api/Ray.java

@@ -56,9 +56,9 @@ public final class Ray extends RayCall {
    * Store an object in the object store.
    *
    * @param obj The Java object to be stored.
-   * @return A RayObject instance that represents the in-store object.
+   * @return A ObjectRef instance that represents the in-store object.
    */
-  public static <T> RayObject<T> put(T obj) {
+  public static <T> ObjectRef<T> put(T obj) {
     return runtime.put(obj);
   }
 
@@ -85,15 +85,15 @@ public final class Ray extends RayCall {
   }
 
   /**
-   * Get a list of objects by RayObjects from the object store.
+   * Get a list of objects by `ObjectRef`s from the object store.
    *
-   * @param objectList A list of RayObject to get.
+   * @param objectList A list of object references.
    * @return A list of Java objects.
    */
-  public static <T> List<T> get(List<RayObject<T>> objectList) {
+  public static <T> List<T> get(List<ObjectRef<T>> objectList) {
     List<ObjectId> objectIds = new ArrayList<>();
     Class<T> objectType = null;
-    for (RayObject<T> o : objectList) {
+    for (ObjectRef<T> o : objectList) {
       objectIds.add(o.getId());
       objectType = o.getType();
     }
@@ -104,13 +104,13 @@ public final class Ray extends RayCall {
    * Wait for a list of RayObjects to be locally available,
    * until specified number of objects are ready, or specified timeout has passed.
    *
-   * @param waitList A list of RayObject to wait for.
+   * @param waitList A list of object references to wait for.
    * @param numReturns The number of objects that should be returned.
    * @param timeoutMs The maximum time in milliseconds to wait before returning.
    * @return Two lists, one containing locally available objects, one containing the rest.
    */
-  public static <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns,
-      int timeoutMs) {
+  public static <T> WaitResult<T> wait(List<ObjectRef<T>> waitList, int numReturns,
+                                       int timeoutMs) {
     return runtime.wait(waitList, numReturns, timeoutMs);
   }
 
@@ -118,11 +118,11 @@ public final class Ray extends RayCall {
    * A convenient helper method for Ray.wait. It will wait infinitely until
    * specified number of objects are locally available.
    *
-   * @param waitList A list of RayObject to wait for.
+   * @param waitList A list of object references to wait for.
    * @param numReturns The number of objects that should be returned.
    * @return Two lists, one containing locally available objects, one containing the rest.
    */
-  public static <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns) {
+  public static <T> WaitResult<T> wait(List<ObjectRef<T>> waitList, int numReturns) {
     return runtime.wait(waitList, numReturns, Integer.MAX_VALUE);
   }
 
@@ -130,10 +130,10 @@ public final class Ray extends RayCall {
    * A convenient helper method for Ray.wait. It will wait infinitely until
    * all objects are locally available.
    *
-   * @param waitList A list of RayObject to wait for.
+   * @param waitList A list of object references to wait for.
    * @return Two lists, one containing locally available objects, one containing the rest.
    */
-  public static <T> WaitResult<T> wait(List<RayObject<T>> waitList) {
+  public static <T> WaitResult<T> wait(List<ObjectRef<T>> waitList) {
     return runtime.wait(waitList, waitList.size(), Integer.MAX_VALUE);
   }
 

java/api/src/main/java/io/ray/api/WaitResult.java

@@ -8,10 +8,10 @@ import java.util.List;
  */
 public final class WaitResult<T> {
 
-  private final List<RayObject<T>> ready;
-  private final List<RayObject<T>> unready;
+  private final List<ObjectRef<T>> ready;
+  private final List<ObjectRef<T>> unready;
 
-  public WaitResult(List<RayObject<T>> ready, List<RayObject<T>> unready) {
+  public WaitResult(List<ObjectRef<T>> ready, List<ObjectRef<T>> unready) {
     this.ready = ready;
     this.unready = unready;
   }
@@ -19,14 +19,14 @@ public final class WaitResult<T> {
   /**
    * Get the list of ready objects.
    */
-  public List<RayObject<T>> getReady() {
+  public List<ObjectRef<T>> getReady() {
     return ready;
   }
 
   /**
    * Get the list of unready objects.
    */
-  public List<RayObject<T>> getUnready() {
+  public List<ObjectRef<T>> getUnready() {
     return unready;
   }
 

java/api/src/main/java/io/ray/api/function/PyActorClass.java

@@ -18,7 +18,7 @@ package io.ray.api.function;
  * we can create this Python actor from Java:
  *
  * {@code
- * RayPyActor actor = Ray.createActor(new PyActorClass("example_package.example_module", "A"),
+ * PyActorHandle actor = Ray.createActor(new PyActorClass("example_package.example_module", "A"),
  *                                    "the value for x");
  * }
  * </pre>

java/api/src/main/java/io/ray/api/function/PyActorMethod.java

@@ -17,14 +17,14 @@ package io.ray.api.function;
  * suppose we have got the Python actor class A's handle in Java
  *
  * {@code
- * RayPyActor actor = ...; // returned from Ray.createActor or passed from Python
+ * PyActorHandle actor = ...; // returned from Ray.createActor or passed from Python
  * }
  *
  * then we can call the actor method:
  *
  * {@code
  * // A.foo returns a string, so we have to set the returnType to String.class
- * RayObject<String> res = actor.call(new PyActorMethod<>("foo", String.class));
+ * ObjectRef<String> res = actor.call(new PyActorMethod<>("foo", String.class));
  * String x = res.get();
  * }
  * </pre>

java/api/src/main/java/io/ray/api/function/PyRemoteFunction.java

@@ -18,13 +18,13 @@ package io.ray.api.function;
  *
  * {@code
  * // bar returns input, so we have to set the returnType to int.class if bar accepts an int
- * RayObject<Integer> res = actor.call(
+ * ObjectRef<Integer> res = actor.call(
  *    new PyRemoteFunction<>("example_package.example_module", "bar", Integer.class),
  *    1);
  * Integer value = res.get();
  *
  * // bar returns input, so we have to set the returnType to String.class if bar accepts a string
- * RayObject<String> res = actor.call(
+ * ObjectRef<String> res = actor.call(
  *    new PyRemoteFunction<>("example_package.example_module", "bar", String.class),
  *    "Hello world!");
  * String value = res.get();

java/api/src/main/java/io/ray/api/runtime/RayRuntime.java

@@ -1,9 +1,9 @@
 package io.ray.api.runtime;
 
-import io.ray.api.BaseActor;
-import io.ray.api.RayActor;
-import io.ray.api.RayObject;
-import io.ray.api.RayPyActor;
+import io.ray.api.ActorHandle;
+import io.ray.api.BaseActorHandle;
+import io.ray.api.ObjectRef;
+import io.ray.api.PyActorHandle;
 import io.ray.api.WaitResult;
 import io.ray.api.function.PyActorClass;
 import io.ray.api.function.PyActorMethod;
@@ -31,9 +31,9 @@ public interface RayRuntime {
    * Store an object in the object store.
    *
    * @param obj The Java object to be stored.
-   * @return A RayObject instance that represents the in-store object.
+   * @return A ObjectRef instance that represents the in-store object.
    */
-  <T> RayObject<T> put(T obj);
+  <T> ObjectRef<T> put(T obj);
 
   /**
    * Get an object from the object store.
@@ -57,12 +57,12 @@ public interface RayRuntime {
    * Wait for a list of RayObjects to be locally available, until specified number of objects are
    * ready, or specified timeout has passed.
    *
-   * @param waitList A list of RayObject to wait for.
+   * @param waitList A list of ObjectRef to wait for.
    * @param numReturns The number of objects that should be returned.
    * @param timeoutMs The maximum time in milliseconds to wait before returning.
    * @return Two lists, one containing locally available objects, one containing the rest.
    */
-  <T> WaitResult<T> wait(List<RayObject<T>> waitList, int numReturns, int timeoutMs);
+  <T> WaitResult<T> wait(List<ObjectRef<T>> waitList, int numReturns, int timeoutMs);
 
   /**
    * Free a list of objects from Plasma Store.
@@ -88,7 +88,7 @@ public interface RayRuntime {
    * @param actor The actor to be killed.
    * @param noRestart If set to true, the killed actor will not be restarted anymore.
    */
-  void killActor(BaseActor actor, boolean noRestart);
+  void killActor(BaseActorHandle actor, boolean noRestart);
 
   /**
    * Invoke a remote function.
@@ -98,7 +98,7 @@ public interface RayRuntime {
    * @param options The options for this call.
    * @return The result object.
    */
-  RayObject call(RayFunc func, Object[] args, CallOptions options);
+  ObjectRef call(RayFunc func, Object[] args, CallOptions options);
 
   /**
    * Invoke a remote Python function.
@@ -108,7 +108,7 @@ public interface RayRuntime {
    * @param options The options for this call.
    * @return The result object.
    */
-  RayObject call(PyRemoteFunction pyRemoteFunction, Object[] args, CallOptions options);
+  ObjectRef call(PyRemoteFunction pyRemoteFunction, Object[] args, CallOptions options);
 
   /**
    * Invoke a remote function on an actor.
@@ -118,7 +118,7 @@ public interface RayRuntime {
    * @param args The arguments of the remote function.
    * @return The result object.
    */
-  RayObject callActor(RayActor<?> actor, RayFunc func, Object[] args);
+  ObjectRef callActor(ActorHandle<?> actor, RayFunc func, Object[] args);
 
   /**
    * Invoke a remote Python function on an actor.
@@ -128,7 +128,7 @@ public interface RayRuntime {
    * @param args Arguments of the function.
    * @return The result object.
    */
-  RayObject callActor(RayPyActor pyActor, PyActorMethod pyActorMethod, Object[] args);
+  ObjectRef callActor(PyActorHandle pyActor, PyActorMethod pyActorMethod, Object[] args);
 
   /**
    * Create an actor on a remote node.
@@ -139,8 +139,8 @@ public interface RayRuntime {
    * @param options The options for creating actor.
    * @return A handle to the actor.
    */
-  <T> RayActor<T> createActor(RayFunc actorFactoryFunc, Object[] args,
-      ActorCreationOptions options);
+  <T> ActorHandle<T> createActor(RayFunc actorFactoryFunc, Object[] args,
+                                 ActorCreationOptions options);
 
   /**
    * Create a Python actor on a remote node.
@@ -150,8 +150,8 @@ public interface RayRuntime {
    * @param options The options for creating actor.
    * @return A handle to the actor.
    */
-  RayPyActor createActor(PyActorClass pyActorClass, Object[] args,
-                         ActorCreationOptions options);
+  PyActorHandle createActor(PyActorClass pyActorClass, Object[] args,
+                            ActorCreationOptions options);
 
   RuntimeContext getRuntimeContext();