Callable Objects in Java, C#, Rust, and C++

It is trivial to make a class callable in C++. Just define operator(). But what if you cannot? My ACCU 2023 online talk.

Transcript

1. ♯ ++
2. zobj = zipfile.open("some") zobj.read(name) # -> bytes def foo(cb: Callable[[str], bytes]) -> None: ...
3. • def • lambda • functools.partial • __call__
4. • __call__ • ZipFile • __call__ ZipFile • ZipFile.extract (name: str) -> None
6. • def • lambda • functools.partial • __call__ • myobj.read
7. • • ♯ • operator() •
9. • std::thread void • java.lang.Thread Runnable class Thread { Thread(Runnable target) {
10. • Runnable public interface Runnable { void run(); }
11. class MyRunnable implements Runnable { public void run() { System.out.println("MyRunnable running"); } } MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); thread.start();
12. Thread thread = new Thread(() -> { System.out.println("MyRunnable running"); }); thread.start();
13. • public interface Runnable { void run(); }
14. Thread thread = new Thread(() -> { System.out.println("MyRunnable running"); });
15. class lambda$1 implements Runnable { public void run() { System.out.println("MyRunnable running"); } } Thread thread = new Thread(new lambda$1());
16. __call__
17. public interface Function<T,R> { R apply(T t); } class ZipFile { byte[] read(int) { } } public class Tab { static Tab take(Function<String,byte[]> g);
18. public interface Function<T,R> { R apply(T t); } class ZipFile { byte[] read(int) { } } ZipFile zipped = new ZipFile("input.zip"); Tab::take(/* ?? */);
19. public interface Function<T,R> { R apply(T t); } class ZipFile { byte[] read(int) { } } ZipFile zipped = new ZipFile("input.zip"); Tab::take(zipped::read);
20. class lambda$1 implements Function<String,byte[]> { final ZipFile arg0; byte[] apply(String t) { return arg0.read(t); } } ZipFile zipped = new ZipFile("input.zip"); Tab::take(new lambda$1(zipped));
21. • MyRunnable • lambda$1 • lambda$2
22. •
23. • void run() vptr … System.out.println("M yRunnable running");
24. • • void run() … System.out.println("M yRunnable running");
25. class Foo { public void test() { Thread thread = new Thread(() -> { System.out.println("MyRunnable running"); }); thread.start(); } }
26. class Foo { private static void lambda$test$0() { System.out.println("MyRunnable running"); } public void test() { Thread thread = new Thread( /* a callsite object to invoke lambda$test$0 */ ); thread.start(); } }
27. void run() … System.out.println("M yRunnable running");
28. • void run() System.out.println("M yRunnable running"); CallSite MethodHandle
29. ♯
30. ♯ operator()
31. ♯ • public interface Runnable { void run(); } • ♯ public delegate void Runnable();
32. ♯ • public interface Runnable { void run(); } • ♯ public delegate void ThreadStart();
33. class MyRunnable implements Runnable { public void run() { System.out.println("MyRunnable running"); } } MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable); thread.start();
34. class MyRunnable { public void run() { Console.WriteLine("MyRunnable running"); } } MyRunnable myRunnable = new MyRunnable(); Thread thread = new Thread(myRunnable.run); thread.Start();
35. myRunnable.run new ThreadStart(myRunnable.run)
36. new Lambda__1(myRunnable.run)
37. internal class Delegate__ThreadStart { public virtual void Invoke(); } internal class Lambda__1 : Delegate__ThreadStart { readonly MyRunnable arg0; public override void Invoke() { arg0.run(); } }
38. internal class Delegate__ThreadStart : System.Delegate { public virtual void Invoke(); } namespace System { public abstract partial class Delegate { // null if static delegate internal object? _target; // _methodPtr could point to a thunk internal IntPtr _methodPtr;
39. void run() System.out.println("M yRunnable running"); MethodHandle
40. myRunnable.run ♯ MyRunnable::run myRunnable void ThreadStart() _target _methodPtr
42. namespace System { public abstract partial class Delegate { // null if static delegate internal object? _target; // _methodPtr could point to a thunk internal IntPtr _methodPtr;
43. namespace std { template <typename Ret, typename... Params> class function_ref<Ret(Params...)> { // null if free function void *_target = nullptr; // _methodPtr points to a thunk Ret (*_methodPtr)(void *, Params...);
45. pub trait Callable<Args> where Args: Tuple, { fn call(&self, args: Args); }
46. struct MyReportingCallback { name: String, // more fields } impl MyReportingCallback { // member functions go here }
47. impl MyReportingCallback { fn notify(&self, status: WorkResult, ref obj: Data) {} } fn accept<T: Callable<(WorkResult, Data)>>(cb: &T) { let w = WorkResult {}; let o = Data {}; cb.call((w, o)); }
48. impl MyReportingCallback { fn notify(&self, status: WorkResult, ref obj: Data) {} } impl Callable<(WorkResult, Data)> for MyReportingCallback { fn call(&self, (status, object): (WorkResult, Data)) { self.notify(status, object); } }
49. • trait Callable<Args> { fn call(&self, args: Args); } • template<class Fn, class... T> concept invocable = std::is_invocable_v<Fn, T...>;
50. • fn accept<T>(cb: &T) where T: Callable<(WorkResult, Data)> • template<invocable<WorkResult, Data&> T> void accept(T cb);
51. trait Callable<Args> { fn call(&self, args: Args); } impl Callable<(WorkResult, Data)> for MyReportingCallback { fn call(&self, (status, object): (WorkResult, Data)) { self.notify(status, object); } }
52. concept invocable<class Fn, class... T> { /*...*/ }; concept_map invocable<MyReportingCallback, WorkResult, Data&> { using operator() = MyReportingCallback::notify; };
53. pub trait FnOnce<Args> where Args: Tuple, { type Output; extern "rust-call" fn call_once(self, args: Args) -> Self::Output; } // std::thread pub fn spawn<F, T>(f: F) -> JoinHandle<T> where F: FnOnce() -> T
54. fn accept<T>(cb: &T) where T: Callable<(WorkResult, Data)> fn accept(cb: &dyn Callable<(WorkResult, Data)>)
55. • impl • impl • MyReportingCallback IDoWorkCallback Callable<(WorkResult, Data)>
57. class CDraw : public IDraw { Color color_; public: void draw() override; void set_color(Color) override; ~CDraw() = default; }; class IDraw { public: virtual void draw() = 0; virtual void set_color(Color) = 0; ~IDraw() = default; };
58. vtable CDraw for IDraw void draw(); void set_color(Color); ~IDraw() vptr … Color color_;
59. constinit Drawable DrawableImpl = { .draw = [](void *this_) {}, .set_color = [](void *this_, Color color) {}, .destroy = [](void *this_) {}, }; struct Drawable { typedef void draw_t(void *); typedef void set_color_t(void *, Color); typedef void destroy_t(void *); draw_t *draw; set_color_t *set_color; destroy_t *destroy; };
60. DrawableImpl static object void (*draw)(void *); void (*set_color)(void *, Color); void (*destroy)(void *); ref-wrap<Drawable const> CDraw rep_; ref-wrap<Drawable const> void *obj_;
61. DrawableImpl static object void (*draw)(void *); void (*set_color)(void *, Color); void (*destroy)(void *); Drawable const & unique_ptr<void> rep_; Drawable const & void *obj_;
62. Drawable const & unique_ptr<void> rep_; Drawable const & void *obj_; Box<dyn Drawable> &dyn Drawable
63. Drawable const & void *rep_; Drawable const & void *obj_; dyn Drawable dyn Drawable
64. constinit Drawable DrawableImpl = { .draw = [](void *this_) {}, .set_color = [](void *this_, Color color) {}, .destroy = [](void *this_) {}, }; struct Drawable { typedef void draw_t(void *); typedef void set_color_t(void *, Color); typedef void destroy_t(void *); draw_t *draw; set_color_t *set_color; destroy_t *destroy; };
65. impl Drawable for MyType { fn draw() { } fn set_color(color: Color) { } fn destroy() { } } trait Drawable { fn draw(); fn set_color(_: Color); fn destroy(); }
66. ✓ ✓ ✓ Existential container Witness table
68. function_ref<R(Args...)> function_ref<R(Args...) const> move_only_function<R(Args...)> move_only_function<R(Args...) const> copyable_function<R(Args...)> copyable_function<R(Args...) const> &dyn FnMut<(Args) -> R> &dyn Fn<(Args) -> R> Box<dyn FnMut<(Args) -> R>> Box<dyn Fn<(Args) -> R>> Box<dyn Clone + FnMut<(Args) -> R>> Box<dyn Clone + Fn<(Args) -> R>>
69. struct MyReportingCallback { void notify(WorkResult status, Data& object); }; void accept(std::function_ref<void(WorkResult, Data&)> cb);
70. MyReportingCallback cb; accept({std::nontype<&MyReportingCallback::notify>, cb});
71. MyReportingCallback cb; accept({std::nontype< [](auto &cb, WorkResult status, Data &object) { LOG(INFO) << "status: " << status; cb.notify(status, object); }>, cb});
72. concept_map invocable<MyReportingCallback, WorkResult, Data&> { using operator() = MyReportingCallback::notify; };
73. concept_map invocable<MyReportingCallback, WorkResult, Data&> { using operator() = MyReportingCallback::notify; };
74. constinit Drawable DrawableImpl = { .draw = [](void *this_) {}, .set_color = [](void *this_, Color color) {}, .destroy = [](void *this_) {}, };
75. constinit Drawable DrawableImpl = { .draw = [](void *this_) {}, .set_color = [](void *this_, Color color) {}, .destroy = [](void *this_) {}, };
76. MyReportingCallback cb; accept({std::nontype< [](auto &cb, WorkResult status, Data &object) { LOG(INFO) << "status: " << status; cb.notify(status, object); }>, cb});
77. template<class T> inline constexpr auto impl_invocable_for = std::nontype<void>; template<> inline constexpr auto impl_invocable_for<MyReportingCallback> = std::nontype< [](auto &cb, WorkResult status, Data &object) { LOG(INFO) << "status: " << status; cb.notify(status, object); }>; MyReportingCallback cb; accept({impl_invocable_for<MyReportingCallback>, cb});
78. • () • + + () • ++