[Java] Refactor java api (#8858)

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

@@ -2,6 +2,8 @@
 
 package io.ray.api;
 
+import io.ray.api.call.ActorTaskCaller;
+import io.ray.api.call.VoidActorTaskCaller;
 import io.ray.api.function.RayFunc1;
 import io.ray.api.function.RayFunc2;
 import io.ray.api.function.RayFunc3;
@@ -18,637 +20,636 @@ import io.ray.api.function.RayFuncVoid6;
 /**
  * This class provides type-safe interfaces for remote actor calls.
  **/
-@SuppressWarnings({"rawtypes", "unchecked"})
 interface ActorCall<A> {
 
-  default <R> ObjectRef<R> call(RayFunc1<A, R> f) {
+  default <R> ActorTaskCaller<R> task(RayFunc1<A, R> f) {
     Object[] args = new Object[]{};
-    return Ray.internal().callActor((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default void call(RayFuncVoid1<A> f) {
+  default VoidActorTaskCaller task(RayFuncVoid1<A> f) {
     Object[] args = new Object[]{};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, R> ObjectRef<R> call(RayFunc2<A, T0, R> f, T0 t0) {
+  default <T0, R> ActorTaskCaller<R> task(RayFunc2<A, T0, R> f, T0 t0) {
     Object[] args = new Object[]{t0};
-    return Ray.internal().callActor((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, R> ObjectRef<R> call(RayFunc2<A, T0, R> f, ObjectRef<T0> t0) {
+  default <T0, R> ActorTaskCaller<R> task(RayFunc2<A, T0, R> f, ObjectRef<T0> t0) {
     Object[] args = new Object[]{t0};
-    return Ray.internal().callActor((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0> void call(RayFuncVoid2<A, T0> f, T0 t0) {
+  default <T0> VoidActorTaskCaller task(RayFuncVoid2<A, T0> f, T0 t0) {
     Object[] args = new Object[]{t0};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0> void call(RayFuncVoid2<A, T0> f, ObjectRef<T0> t0) {
+  default <T0> VoidActorTaskCaller task(RayFuncVoid2<A, T0> f, ObjectRef<T0> t0) {
     Object[] args = new Object[]{t0};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, R> ObjectRef<R> call(RayFunc3<A, T0, T1, R> f, T0 t0, T1 t1) {
+  default <T0, T1, R> ActorTaskCaller<R> task(RayFunc3<A, T0, T1, R> f, T0 t0, T1 t1) {
     Object[] args = new Object[]{t0, t1};
-    return Ray.internal().callActor((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, R> ObjectRef<R> call(RayFunc3<A, T0, T1, R> f, T0 t0, ObjectRef<T1> t1) {
+  default <T0, T1, R> ActorTaskCaller<R> task(RayFunc3<A, T0, T1, R> f, T0 t0, ObjectRef<T1> t1) {
     Object[] args = new Object[]{t0, t1};
-    return Ray.internal().callActor((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, R> ObjectRef<R> call(RayFunc3<A, T0, T1, R> f, ObjectRef<T0> t0, T1 t1) {
+  default <T0, T1, R> ActorTaskCaller<R> task(RayFunc3<A, T0, T1, R> f, ObjectRef<T0> t0, T1 t1) {
     Object[] args = new Object[]{t0, t1};
-    return Ray.internal().callActor((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, R> ObjectRef<R> call(RayFunc3<A, T0, T1, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1) {
+  default <T0, T1, R> ActorTaskCaller<R> task(RayFunc3<A, T0, T1, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1) {
     Object[] args = new Object[]{t0, t1};
-    return Ray.internal().callActor((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, T0 t0, T1 t1) {
+  default <T0, T1> VoidActorTaskCaller task(RayFuncVoid3<A, T0, T1> f, T0 t0, T1 t1) {
     Object[] args = new Object[]{t0, t1};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, T0 t0, ObjectRef<T1> t1) {
+  default <T0, T1> VoidActorTaskCaller task(RayFuncVoid3<A, T0, T1> f, T0 t0, ObjectRef<T1> t1) {
     Object[] args = new Object[]{t0, t1};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, ObjectRef<T0> t0, T1 t1) {
+  default <T0, T1> VoidActorTaskCaller task(RayFuncVoid3<A, T0, T1> f, ObjectRef<T0> t0, T1 t1) {
     Object[] args = new Object[]{t0, t1};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1> void call(RayFuncVoid3<A, T0, T1> f, ObjectRef<T0> t0, ObjectRef<T1> t1) {
+  default <T0, T1> VoidActorTaskCaller task(RayFuncVoid3<A, T0, T1> f, ObjectRef<T0> t0, ObjectRef<T1> t1) {
     Object[] args = new Object[]{t0, t1};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, T1 t1, T2 t2) {
+  default <T0, T1, T2, R> ActorTaskCaller<R> task(RayFunc4<A, T0, T1, T2, R> f, T0 t0, T1 t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    return Ray.internal().callActor((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, T1 t1, ObjectRef<T2> t2) {
+  default <T0, T1, T2, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, ObjectRef<T1> t1, T2 t2) {
+  default <T0, T1, T2, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
+  default <T0, T1, T2, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, ObjectRef<T0> t0, T1 t1, T2 t2) {
+  default <T0, T1, T2, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2) {
+  default <T0, T1, T2, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2) {
+  default <T0, T1, T2, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, R> ObjectRef<R> call(RayFunc4<A, T0, T1, T2, R> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
+  default <T0, T1, T2, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, T1 t1, T2 t2) {
+  default <T0, T1, T2> VoidActorTaskCaller task(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, T1 t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, T1 t1, ObjectRef<T2> t2) {
+  default <T0, T1, T2> VoidActorTaskCaller task(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, T1 t1, ObjectRef<T2> t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, ObjectRef<T1> t1, T2 t2) {
+  default <T0, T1, T2> VoidActorTaskCaller task(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, ObjectRef<T1> t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
+  default <T0, T1, T2> VoidActorTaskCaller task(RayFuncVoid4<A, T0, T1, T2> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, T1 t1, T2 t2) {
+  default <T0, T1, T2> VoidActorTaskCaller task(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, T1 t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2) {
+  default <T0, T1, T2> VoidActorTaskCaller task(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2) {
+  default <T0, T1, T2> VoidActorTaskCaller task(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2) {
     Object[] args = new Object[]{t0, t1, t2};
-    Ray.internal().callActor((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2> void call(RayFuncVoid4<A, T0, T1, T2> f, ObjectRef<T0> t0, ObjectRef<T1> t1, ObjectRef<T2> t2) {
+  default <T0, T1, T2> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((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) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, T2 t2, ObjectRef<T3> t3) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, ObjectRef<T2> t2, T3 t3) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, T1 t1, ObjectRef<T2> t2, ObjectRef<T3> t3) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, ObjectRef<T1> t1, T2 t2, T3 t3) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, ObjectRef<T1> t1, T2 t2, ObjectRef<T3> t3) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, T0 t0, ObjectRef<T1> t1, ObjectRef<T2> t2, T3 t3) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, T1 t1, T2 t2, T3 t3) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, T1 t1, T2 t2, ObjectRef<T3> t3) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, T1 t1, ObjectRef<T2> t2, T3 t3) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  default <T0, T1, T2, T3> void call(RayFuncVoid5<A, T0, T1, T2, T3> f, ObjectRef<T0> t0, ObjectRef<T1> t1, T2 t2, T3 t3) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4, R> ActorTaskCaller<R> task(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((ActorHandle) this, f, args);
+    return new ActorTaskCaller<>((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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((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, ObjectRef<T4> t4) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((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, ObjectRef<T3> t3, T4 t4) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((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, ObjectRef<T3> t3, ObjectRef<T4> t4) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
-  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) {
+  default <T0, T1, T2, T3, T4> VoidActorTaskCaller task(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((ActorHandle) this, f, args);
+    return new VoidActorTaskCaller((ActorHandle) this, f, args);
   }
 
 }

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

@@ -2,42 +2,42 @@
 
 package io.ray.api;
 
+import io.ray.api.call.PyActorTaskCaller;
 import io.ray.api.function.PyActorMethod;
 
 /**
  * This class provides type-safe interfaces for remote actor calls.
  **/
-@SuppressWarnings({"rawtypes", "unchecked"})
 interface PyActorCall {
 
-  default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod) {
+  default <R> PyActorTaskCaller<R> task(PyActorMethod<R> pyActorMethod) {
     Object[] args = new Object[]{};
-    return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
+    return new PyActorTaskCaller<>((PyActorHandle)this, pyActorMethod, args);
   }
 
-  default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0) {
+  default <R> PyActorTaskCaller<R> task(PyActorMethod<R> pyActorMethod, Object obj0) {
     Object[] args = new Object[]{obj0};
-    return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
+    return new PyActorTaskCaller<>((PyActorHandle)this, pyActorMethod, args);
   }
 
-  default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1) {
+  default <R> PyActorTaskCaller<R> task(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1) {
     Object[] args = new Object[]{obj0, obj1};
-    return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
+    return new PyActorTaskCaller<>((PyActorHandle)this, pyActorMethod, args);
   }
 
-  default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2) {
+  default <R> PyActorTaskCaller<R> task(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2) {
     Object[] args = new Object[]{obj0, obj1, obj2};
-    return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
+    return new PyActorTaskCaller<>((PyActorHandle)this, pyActorMethod, args);
   }
 
-  default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2, Object obj3) {
+  default <R> PyActorTaskCaller<R> task(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2, Object obj3) {
     Object[] args = new Object[]{obj0, obj1, obj2, obj3};
-    return Ray.internal().callActor((PyActorHandle)this, pyActorMethod, args);
+    return new PyActorTaskCaller<>((PyActorHandle)this, pyActorMethod, args);
   }
 
-  default <R> ObjectRef<R> call(PyActorMethod<R> pyActorMethod, Object obj0, Object obj1, Object obj2, Object obj3, Object obj4) {
+  default <R> PyActorTaskCaller<R> task(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((PyActorHandle)this, pyActorMethod, args);
+    return new PyActorTaskCaller<>((PyActorHandle)this, pyActorMethod, args);
   }
 
 }

java/api/src/main/java/io/ray/api/call/ActorCreator.java

@@ -0,0 +1,38 @@
+package io.ray.api.call;
+
+import io.ray.api.ActorHandle;
+import io.ray.api.Ray;
+import io.ray.api.function.RayFuncR;
+
+/**
+ * A helper to create java actor.
+ *
+ * @param <A> The type of the concrete actor class.
+ */
+public class ActorCreator<A> extends BaseActorCreator<ActorCreator<A>> {
+  private final RayFuncR<A> func;
+  private final Object[] args;
+
+  public ActorCreator(RayFuncR<A> func, Object[] args) {
+    this.func = func;
+    this.args = args;
+  }
+
+  /**
+   * @see io.ray.api.options.ActorCreationOptions.Builder#setJvmOptions(java.lang.String)
+   */
+  public ActorCreator<A> setJvmOptions(String jvmOptions) {
+    builder.setJvmOptions(jvmOptions);
+    return this;
+  }
+
+  /**
+   * Create a java actor remotely and return a handle to the created actor.
+   *
+   * @return a handle to the created java actor.
+   */
+  public ActorHandle<A> remote() {
+    return Ray.internal().createActor(func, args, buildOptions());
+  }
+
+}

java/api/src/main/java/io/ray/api/call/ActorTaskCaller.java

@@ -0,0 +1,35 @@
+package io.ray.api.call;
+
+import io.ray.api.ActorHandle;
+import io.ray.api.ObjectRef;
+import io.ray.api.Ray;
+import io.ray.api.function.RayFuncR;
+
+/**
+ * A helper to call java actor method.
+ *
+ * @param <R> The type of the java actor method return value
+ */
+public class ActorTaskCaller<R> {
+  private final ActorHandle actor;
+  private final RayFuncR<R> func;
+  private final Object[] args;
+
+  public ActorTaskCaller(ActorHandle actor, RayFuncR<R> func, Object[] args) {
+    this.actor = actor;
+    this.func = func;
+    this.args = args;
+  }
+
+  /**
+   * Execute an java actor method remotely and return an object reference to the result object in
+   * the object store.
+   *
+   * @return an object reference to an object in the object store.
+   */
+  @SuppressWarnings("unchecked")
+  public ObjectRef<R> remote() {
+    return Ray.internal().callActor(actor, func, args);
+  }
+
+}

java/api/src/main/java/io/ray/api/call/BaseActorCreator.java

@@ -0,0 +1,82 @@
+package io.ray.api.call;
+
+import io.ray.api.options.ActorCreationOptions;
+import java.util.Map;
+
+/**
+ * Base helper to create actor.
+ *
+ * @param <T> The type of the concrete actor creator
+ */
+public class BaseActorCreator<T extends BaseActorCreator> {
+  protected ActorCreationOptions.Builder builder = new ActorCreationOptions.Builder();
+
+  /**
+   * Set a custom resource requirement to reserve for the lifetime of this actor.
+   * This method can be called multiple times. If the same resource is set multiple times,
+   * the latest quantity will be used.
+   *
+   * @param resourceName resource name
+   * @param resourceQuantity resource quantity
+   * @return self
+   * @see ActorCreationOptions.Builder#setResource(java.lang.String, java.lang.Double)
+   */
+  public T setResource(String resourceName, Double resourceQuantity) {
+    builder.setResource(resourceName, resourceQuantity);
+    return self();
+  }
+
+  /**
+   * Set custom resource requirements to reserve for the lifetime of this actor.
+   * This method can be called multiple times. If the same resource is set multiple times,
+   * the latest quantity will be used.
+   *
+   * @param resources requirements for multiple resources.
+   * @return self
+   * @see BaseActorCreator#setResources(java.util.Map)
+   */
+  public T setResources(Map<String, Double> resources) {
+    builder.setResources(resources);
+    return self();
+  }
+
+  /**
+   * This specifies the maximum number of times that the actor should be restarted when it dies
+   * unexpectedly. The minimum valid value is 0 (default), which indicates that the actor doesn't
+   * need to be restarted. A value of -1 indicates that an actor should be restarted indefinitely.
+   *
+   * @param maxRestarts max number of actor restarts
+   * @return self
+   * @see ActorCreationOptions.Builder#setMaxRestarts(int)
+   */
+  public T setMaxRestarts(int maxRestarts) {
+    builder.setMaxRestarts(maxRestarts);
+    return self();
+  }
+
+  /**
+   /**
+   * Set the max number of concurrent calls to allow for this actor.
+   *
+   * The max concurrency defaults to 1 for threaded execution.
+   * Note that the execution order is not guaranteed when max_concurrency > 1.
+   *
+   * @param maxConcurrency The max number of concurrent calls to allow for this actor.
+   * @return self
+   * @see ActorCreationOptions.Builder#setMaxConcurrency(int)
+   */
+  public T setMaxConcurrency(int maxConcurrency) {
+    builder.setMaxConcurrency(maxConcurrency);
+    return self();
+  }
+
+  @SuppressWarnings("unchecked")
+  private T self() {
+    return (T) this;
+  }
+
+  protected ActorCreationOptions buildOptions() {
+    return builder.build();
+  }
+
+}

java/api/src/main/java/io/ray/api/call/BaseTaskCaller.java

@@ -0,0 +1,52 @@
+package io.ray.api.call;
+
+import io.ray.api.options.CallOptions;
+import java.util.Map;
+
+/**
+ * Base helper to call remote function.
+ *
+ * @param <T> The type of the concrete task caller
+ */
+public class BaseTaskCaller<T extends BaseTaskCaller<T>> {
+  private CallOptions.Builder builder = new CallOptions.Builder();
+
+  /**
+   * Set a custom resource requirement for resource {@code name}.
+   * This method can be called multiple times. If the same resource is set multiple times,
+   * the latest quantity will be used.
+   *
+   * @param name resource name
+   * @param value resource capacity
+   * @return self
+   * @see CallOptions.Builder#setResource(java.lang.String, java.lang.Double)
+   */
+  public T setResource(String name, Double value) {
+    builder.setResource(name, value);
+    return self();
+  }
+
+  /**
+   * Set custom requirements for multiple resources.
+   * This method can be called multiple times. If the same resource is set multiple times,
+   * the latest quantity will be used.
+   *
+   * @param resources requirements for multiple resources.
+   * @return self
+   * @see CallOptions.Builder#setResources(java.util.Map)
+   */
+  public T setResources(Map<String, Double> resources) {
+    builder.setResources(resources);
+    return self();
+  }
+
+  @SuppressWarnings("unchecked")
+  private T self() {
+    return (T) this;
+  }
+
+  protected CallOptions buildOptions() {
+    return builder.build();
+  }
+
+}

java/api/src/main/java/io/ray/api/call/PyActorCreator.java

@@ -0,0 +1,27 @@
+package io.ray.api.call;
+
+import io.ray.api.PyActorHandle;
+import io.ray.api.Ray;
+import io.ray.api.function.PyActorClass;
+
+/**
+ * A helper to create python actor.
+ */
+public class PyActorCreator extends BaseActorCreator<PyActorCreator> {
+  private final PyActorClass pyActorClass;
+  private final Object[] args;
+
+  public PyActorCreator(PyActorClass pyActorClass, Object[] args) {
+    this.pyActorClass = pyActorClass;
+    this.args = args;
+  }
+
+  /**
+   * Create a python actor remotely and return a handle to the created actor.
+   *
+   * @return a handle to the created python actor.
+   */
+  public PyActorHandle remote() {
+    return Ray.internal().createActor(pyActorClass, args, buildOptions());
+  }
+}

java/api/src/main/java/io/ray/api/call/PyActorTaskCaller.java

@@ -0,0 +1,35 @@
+package io.ray.api.call;
+
+import io.ray.api.ObjectRef;
+import io.ray.api.PyActorHandle;
+import io.ray.api.Ray;
+import io.ray.api.function.PyActorMethod;
+
+/**
+ * A helper to call python actor method.
+ *
+ * @param <R> The type of the python actor method return value
+ */
+public class PyActorTaskCaller<R> {
+  private final PyActorHandle actor;
+  private final PyActorMethod<R> method;
+  private final Object[] args;
+
+  public PyActorTaskCaller(PyActorHandle actor, PyActorMethod<R> method, Object[] args) {
+    this.actor = actor;
+    this.method = method;
+    this.args = args;
+  }
+
+  /**
+   * Execute a python actor method remotely and return an object reference to the result object in
+   * the object store.
+   *
+   * @return an object reference to an object in the object store.
+   */
+  @SuppressWarnings("unchecked")
+  public ObjectRef<R> remote() {
+    return Ray.internal().callActor(actor, method, args);
+  }
+
+}

java/api/src/main/java/io/ray/api/call/PyTaskCaller.java

@@ -0,0 +1,32 @@
+package io.ray.api.call;
+
+import io.ray.api.ObjectRef;
+import io.ray.api.Ray;
+import io.ray.api.function.PyRemoteFunction;
+
+/**
+ * A helper to call python remote function.
+ *
+ * @param <R> The type of the python function return value
+ */
+public class PyTaskCaller<R> extends BaseTaskCaller<PyTaskCaller<R>> {
+  private final PyRemoteFunction<R> func;
+  private final Object[] args;
+
+  public PyTaskCaller(PyRemoteFunction<R> func, Object[] args) {
+    this.func = func;
+    this.args = args;
+  }
+
+  /**
+   * Execute a python function remotely and return an object reference to the result object in the
+   * object store.
+   *
+   * @return an object reference to an object in the object store.
+   */
+  @SuppressWarnings("unchecked")
+  public ObjectRef<R> remote() {
+    return Ray.internal().call(func, args, buildOptions());
+  }
+
+}

java/api/src/main/java/io/ray/api/call/TaskCaller.java

@@ -0,0 +1,31 @@
+package io.ray.api.call;
+
+import io.ray.api.ObjectRef;
+import io.ray.api.Ray;
+import io.ray.api.function.RayFuncR;
+
+/**
+ * A helper to call java remote function.
+ *
+ * @param <R> The type of the java remote function return value
+ */
+public class TaskCaller<R> extends BaseTaskCaller<TaskCaller<R>> {
+  private final RayFuncR<R> func;
+  private final Object[] args;
+
+  public TaskCaller(RayFuncR<R> func, Object[] args) {
+    this.func = func;
+    this.args = args;
+  }
+
+  /**
+   * Execute a java function remotely and return an object reference to the result object in the
+   * object store.
+   *
+   * @return an object reference to an object in the object store.
+   */
+  @SuppressWarnings("unchecked")
+  public ObjectRef<R> remote() {
+    return Ray.internal().call(func, args, buildOptions());
+  }
+}

java/api/src/main/java/io/ray/api/call/VoidActorTaskCaller.java

@@ -0,0 +1,28 @@
+package io.ray.api.call;
+
+import io.ray.api.ActorHandle;
+import io.ray.api.Ray;
+import io.ray.api.function.RayFuncVoid;
+
+/**
+ * A helper to call java actor method which doesn't have a return value.
+ */
+public class VoidActorTaskCaller {
+  private final ActorHandle actor;
+  private final RayFuncVoid func;
+  private final Object[] args;
+
+  public VoidActorTaskCaller(ActorHandle actor, RayFuncVoid func, Object[] args) {
+    this.actor = actor;
+    this.func = func;
+    this.args = args;
+  }
+
+  /**
+   * Execute a function remotely.
+   */
+  public void remote() {
+    Ray.internal().callActor(actor, func, args);
+  }
+
+}

java/api/src/main/java/io/ray/api/call/VoidTaskCaller.java

@@ -0,0 +1,25 @@
+package io.ray.api.call;
+
+import io.ray.api.Ray;
+import io.ray.api.function.RayFuncVoid;
+
+/**
+ * A helper to call java remote function which doesn't have a return value.
+ */
+public class VoidTaskCaller extends BaseTaskCaller<VoidTaskCaller> {
+  private final RayFuncVoid func;
+  private final Object[] args;
+
+  public VoidTaskCaller(RayFuncVoid func, Object[] args) {
+    this.func = func;
+    this.args = args;
+  }
+
+  /**
+   * Execute a function remotely.
+   */
+  public void remote() {
+    Ray.internal().call(func, args, buildOptions());
+  }
+
+}

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

@@ -3,8 +3,7 @@ package io.ray.api.function;
 import java.io.Serializable;
 
 /**
- * Interface of all Ray remote functions.
+ * Base interface of all Ray remote java functions.
  */
 public interface RayFunc extends Serializable {
-
 }

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

@@ -6,7 +6,7 @@ package io.ray.api.function;
  * Functional interface for a remote function that has 0 parameter.
  */
 @FunctionalInterface
-public interface RayFunc0<R> extends RayFunc {
+public interface RayFunc0<R> extends RayFuncR<R> {
 
   R apply() throws Exception;
 }

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

@@ -6,7 +6,7 @@ package io.ray.api.function;
  * Functional interface for a remote function that has 1 parameter.
  */
 @FunctionalInterface
-public interface RayFunc1<T0, R> extends RayFunc {
+public interface RayFunc1<T0, R> extends RayFuncR<R> {
 
   R apply(T0 t0) throws Exception;
 }

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

@@ -6,7 +6,7 @@ package io.ray.api.function;
  * Functional interface for a remote function that has 2 parameters.
  */
 @FunctionalInterface
-public interface RayFunc2<T0, T1, R> extends RayFunc {
+public interface RayFunc2<T0, T1, R> extends RayFuncR<R> {
 
   R apply(T0 t0, T1 t1) throws Exception;
 }

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

@@ -6,7 +6,7 @@ package io.ray.api.function;
  * Functional interface for a remote function that has 3 parameters.
  */
 @FunctionalInterface
-public interface RayFunc3<T0, T1, T2, R> extends RayFunc {
+public interface RayFunc3<T0, T1, T2, R> extends RayFuncR<R> {
 
   R apply(T0 t0, T1 t1, T2 t2) throws Exception;
 }

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

@@ -6,7 +6,7 @@ package io.ray.api.function;
  * Functional interface for a remote function that has 4 parameters.
  */
 @FunctionalInterface
-public interface RayFunc4<T0, T1, T2, T3, R> extends RayFunc {
+public interface RayFunc4<T0, T1, T2, T3, R> extends RayFuncR<R> {
 
   R apply(T0 t0, T1 t1, T2 t2, T3 t3) throws Exception;
 }

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

@@ -6,7 +6,7 @@ package io.ray.api.function;
  * Functional interface for a remote function that has 5 parameters.
  */
 @FunctionalInterface
-public interface RayFunc5<T0, T1, T2, T3, T4, R> extends RayFunc {
+public interface RayFunc5<T0, T1, T2, T3, T4, R> extends RayFuncR<R> {
 
   R apply(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4) throws Exception;
 }

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

@@ -6,7 +6,7 @@ package io.ray.api.function;
  * Functional interface for a remote function that has 6 parameters.
  */
 @FunctionalInterface
-public interface RayFunc6<T0, T1, T2, T3, T4, T5, R> extends RayFunc {
+public interface RayFunc6<T0, T1, T2, T3, T4, T5, R> extends RayFuncR<R> {
 
   R apply(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5) throws Exception;
 }

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

@@ -0,0 +1,10 @@
+package io.ray.api.function;
+
+/**
+ * Interface of all Ray remote functions which have a return value
+ *
+ * @param <R> Type of function return value
+ */
+public interface RayFuncR<R> extends RayFunc {
+
+}

java/api/src/main/java/io/ray/api/options/ActorCreationOptions.java

@@ -31,25 +31,68 @@ public class ActorCreationOptions extends BaseTaskOptions {
     private String jvmOptions = null;
     private int maxConcurrency = 1;
 
-    public Builder setResources(Map<String, Double> resources) {
-      this.resources = resources;
+    /**
+     * Set a custom resource requirement to reserve for the lifetime of this actor.
+     * This method can be called multiple times. If the same resource is set multiple times,
+     * the latest quantity will be used.
+     *
+     * @param resourceName resource name
+     * @param resourceQuantity resource quantity
+     * @return self
+     */
+    public Builder setResource(String resourceName, Double resourceQuantity) {
+      this.resources.put(resourceName, resourceQuantity);
       return this;
     }
 
+    /**
+     * Set custom resource requirements to reserve for the lifetime of this actor.
+     * This method can be called multiple times. If the same resource is set multiple times,
+     * the latest quantity will be used.
+     *
+     * @param resources requirements for multiple resources.
+     * @return self
+     */
+    public Builder setResources(Map<String, Double> resources) {
+      this.resources.putAll(resources);
+      return this;
+    }
+
+    /**
+     * This specifies the maximum number of times that the actor should be restarted when it dies
+     * unexpectedly. The minimum valid value is 0 (default), which indicates that the actor doesn't
+     * need to be restarted. A value of -1 indicates that an actor should be restarted indefinitely.
+     *
+     * @param maxRestarts max number of actor restarts
+     * @return self
+     */
     public Builder setMaxRestarts(int maxRestarts) {
       this.maxRestarts = maxRestarts;
       return this;
     }
 
+    /**
+     * Set the JVM options for the Java worker that this actor is running in.
+     *
+     * Note, if this is set, this actor won't share Java worker with other actors or tasks.
+     *
+     * @param jvmOptions JVM options for the Java worker that this actor is running in.
+     * @return self
+     */
     public Builder setJvmOptions(String jvmOptions) {
       this.jvmOptions = jvmOptions;
       return this;
     }
 
-    // The max number of concurrent calls to allow for this actor.
-    //
-    // The max concurrency defaults to 1 for threaded execution.
-    // Note that the execution order is not guaranteed when max_concurrency > 1.
+    /**
+     * Set the max number of concurrent calls to allow for this actor.
+     *
+     * The max concurrency defaults to 1 for threaded execution.
+     * Note that the execution order is not guaranteed when max_concurrency > 1.
+     *
+     * @param maxConcurrency The max number of concurrent calls to allow for this actor.
+     * @return self
+     */
     public Builder setMaxConcurrency(int maxConcurrency) {
       if (maxConcurrency <= 0) {
         throw new IllegalArgumentException("maxConcurrency must be greater than 0.");
@@ -59,7 +102,7 @@ public class ActorCreationOptions extends BaseTaskOptions {
       return this;
     }
 
-    public ActorCreationOptions createActorCreationOptions() {
+    public ActorCreationOptions build() {
       return new ActorCreationOptions(
           resources, maxRestarts, jvmOptions, maxConcurrency);
     }

java/api/src/main/java/io/ray/api/options/CallOptions.java

@@ -19,12 +19,34 @@ public class CallOptions extends BaseTaskOptions {
 
     private Map<String, Double> resources = new HashMap<>();
 
-    public Builder setResources(Map<String, Double> resources) {
-      this.resources = resources;
+    /**
+     * Set a custom resource requirement for resource {@code name}.
+     * This method can be called multiple times. If the same resource is set multiple times,
+     * the latest quantity will be used.
+     *
+     * @param name resource name
+     * @param value resource capacity
+     * @return self
+     */
+    public Builder setResource(String name, Double value) {
+      this.resources.put(name, value);
       return this;
     }
 
-    public CallOptions createCallOptions() {
+    /**
+     * Set custom requirements for multiple resources.
+     * This method can be called multiple times. If the same resource is set multiple times,
+     * the latest quantity will be used.
+     *
+     * @param resources requirements for multiple resources.
+     * @return self
+     */
+    public Builder setResources(Map<String, Double> resources) {
+      this.resources.putAll(resources);
+      return this;
+    }
+
+    public CallOptions build() {
       return new CallOptions(resources);
     }
   }