Callback2<P1, P2, P2, P3, P4> when_callback;

OnCallback1(P1 p1, P2 p2, P3 p3, P4 p4, T1 t1, T2 t2, T3 t3){
    ...
}

Attach(){when_callback = THISBACK3(OnCallback1, val1, val2, val3)};

#include <Core/Core.h>

using namespace Upp;

struct Foo {
	int x;

	void Action()                { Cout() << "Action: " << x << '\n'; }
	void ActionWithParam(int y)  { Cout() << "ActionWithParam: " << x + y << '\n'; }

	Callback WhenDo;
	Callback1<int> WhenDo1;
	Callback4<int, String, String, String> WhenDo4;
	void Do()                    { WhenDo(); WhenDo1(2);WhenDo4(4, "2 par", "3 par", "4 par");}

	Foo(int x = 0) : x(x) {}
};

void Fn()
{
	Cout() << "Fn!" << '\n';
}

struct Bar {
	Foo foo;

	void Action() { Cout() << "foo's Do called\n"; }
	void ActionMaxPar(int p1, String p2, String p3, String p4) { Cout() << "foo's Do called with max par par 4 = "<<p4<<"\n"; }
	void ActionMaxParAndArg(int p1, String p2, String p3, String p4, int a1, String a2, String a3, String a4) { Cout() << "foo's Do called with max par and arg arg4="<<a4<<"\n"; }

	typedef Bar CLASSNAME;

	Bar() { foo.WhenDo = THISBACK(Action);
		String v_arg1("1 arg");
		String v_arg2("2 arg");
		String v_arg3("3 arg");
		String v_arg4("4 arg");
		int v_arg1_i = 1;
		
		foo.WhenDo1 = THISBACK3(ActionMaxPar, v_arg1, v_arg2, v_arg3);
		foo.WhenDo4 = THISBACK(ActionMaxPar);
		foo.WhenDo4 << THISBACK4(ActionMaxParAndArg, v_arg1_i, v_arg2, v_arg3, v_arg4);
	}
};

struct Safe : Pte<Safe> {
	void Action() { Cout() << "safe action!\n"; }
};

CONSOLE_APP_MAIN
{
	Foo a(10);
	Callback cb1 = callback(&a, &Foo::Action);
	Callback cb2 = callback(Fn);
	Callback1<int> cb3 = callback(&a, &Foo::ActionWithParam);
	Callback cb4 = callback1(&a, &Foo::ActionWithParam, 30);

	cb1();
	cb2();
	cb3(10);
	cb4();

	Cout() << "---------\n";
	cb4 << cb2;
	cb4();

	Cout() << "---------\n";
	Bar b;
	b.foo.Do();

	Cout() << "---------\n";
	{
		Safe f;
		cb4 = pteback(&f, &Safe::Action);
		Cout() << "callback valid: " << (bool)cb4 << '\n';
		cb4();
	}
	Cout() << "callback valid: " << (bool)cb4 << '\n';
	cb4();
}

Class a {
  typedef a THISBACK;
  Callback<int> WenDO;
}
Class b{
  typedef b THISBACK;
  a a_val1;
  void OnDo(int, int);
  void OnDo3(int, int);
  void Initialize(){a_val1.WhenDo = THISBACK1(OnDo, 3);}
}

struct CallbackMethodActionArg1_2 : public Callback2Action<P1, P2> {}

//to

struct Callback2MethodActionArg1 : public Callback2Action<P1, P2> {}

	Callback cb0;
	Callback1<double> cb1;
	Callback2<double, double> cb2;
	Callback3<double, double, double> cb3;
	Callback4<double, double, double, double> cb4;

	Gate gt0;
	Gate1<double> gt1;
	Gate2<double, double> gt2;
	Gate3<double, double, double> gt3;
	Gate4<double, double, double, double> gt4;
	
	//args reduction

	//1 arg to 0 args
	cb0 = callback1(cb1, 1);
	
	//2 args to 1 arg
	cb1 = callback1(cb2, 2);
	cb0 = callback2(cb2, 1, 2);

	//3 args to 2 args
	cb2 = callback1(cb3, 3); //new
	cb0 = callback3(cb3, 1, 2, 3); //new

	//4 args to 3 args
	cb3 = callback1(cb4, 4); //new
	cb0 = callback4(cb4, 1, 2, 3, 4); //new



	//1 arg to 0 args
	gt0 = callback1(gt1, 1); //new
	
	//2 args to 1 arg
	gt1 = callback1(gt2, 2); //new
	gt0 = callback2(gt2, 1, 2); //new

	//3 args to 2 args
	gt2 = callback1(gt3, 3); //new
	gt0 = callback3(gt3, 1, 2, 3); //new

	//4 args to 3 args
	gt3 = callback1(gt4, 4); //new
	gt0 = callback4(gt4, 1, 2, 3, 4); //new

Callback cb = THISBACK(IgnoreReturn(MyMethod));

THISBACKDETR(rettype, method) Callback(new CallbackMethodAction<CLASSNAME, rettype (CLASSNAME::*)()>(this, &CLASSNAME::method)) // can accept functions with return type, but cannot get the returned value
THISBACKDETRP0ARG1(rettype, method, arg1_value)
THISBACKDETRP0ARG2(rettype, method, arg1_value, arg2_value)
THISBACKDETRP0ARG3(rettype, method, arg1_value, arg2_value, arg3_value)
....
THISSIGNDETR(rettype, method) // will return type like Gate but arbitrary type
THISSIGNDETRP0ARG1(rettype, method, arg1_value) // will return type like Gate but arbitrary type