use std::any::*;
use std::sync::*;
+pub trait Callable<Args>: Any {
+ type Output;
+ fn callable_call(self, a: Args) -> Self::Output;
+}
+impl<A, F, O> Callable<(A,)> for F where F: Fn(A) -> O + 'static {
+ type Output = O;
+ fn callable_call(self, (a,): (A,)) -> O { (self)(a) }
+}
+impl<A,B, F, O> Callable<(A,B)> for F where F: Fn(A,B) -> O + 'static {
+ type Output = O;
+ fn callable_call(self, (a,b): (A,B)) -> O { (self)(a,b) }
+}
+
pub trait Object: Any + Send + Sync {}
impl Object for String {}
-pub trait MI {
- fn o_ti(&self) -> TypeId;
- fn call(&self, o: Arc<dyn Any + Send + Sync>) -> usize;
+pub trait MI: Any {
+ fn o_ti(&self) -> TypeId { TypeId::of::<Self>() }
+ fn call(&self, o: Arc<dyn Any + Send + Sync>, u: ()) -> usize;
}
+/*
impl<O: Object> MI for fn(Arc<O>) -> usize {
fn o_ti(&self) -> TypeId { TypeId::of::<O>() }
fn call(&self, o: Arc<dyn Any + Send + Sync>) -> usize {
(self)(Arc::downcast(o).unwrap())
}
-}
+}*/
fn example(o: Arc<String>) -> usize { o.len() }
-const fn k<O: Object, F: Call<O>>(f: &F) -> &dyn MI + '_ {
+/*
+struct K<F>(F);
+
+const fn k<A, F: Callable<A>>(f: F) -> K<F> {
+ f
+}
+
+&dyn MI {
move |o| f(o)
- /*
struct TE(&F);
impl MI for TE {
fn o_ti(&self) -> TypeId { TypeId::of::<O>() }
fn call(&self, o: Arc<dyn Any + Send + Sync>) -> usize {
}
- }*/
+ }
}
+ */
+/*
+struct Thunk<C>(C);
+impl<O, C> MI for Thunk<C>
+where C: Fn((O,)) -> usize
+{
+ fn call(&self, o: Arc<dyn Any + Send + Sync>, u: ()) -> usize {
+ (self)((Arc::downcast(o).unwrap(),))
+ }
+}
+*/
fn main() {
- let v: &dyn MI = k(&example);
+ const CL: () = {
+ |t| Callable::callable_call(example, t);
+ ()
+ };
+//example.callable_call();
+// let v: &dyn MI = k(example);
println!("Hello, world!");
}