#include <iostream>
#include <string>
#include <utility> // For forward
#include <functional>

using namespace std ;

// Primary template definition
template <typename T>
class FunctionHandler
{
	public:
    void handle(T val)
    {
        cout << "Handling generic type: " << typeid(T).name() << endl;
    }
};

// Partial specialization for function types R(Args...)
template <typename R, typename... Args>
class FunctionHandler<R(Args...)>
{
	public:
    void handle(R (*func)(Args...)) {
        cout << "Handling function pointer with return type " << typeid(R).name()
                  << " and arguments: ";
        // A more advanced implementation could iterate through Args... to print types
        cout << " (function pointer)" << endl;
        //callable_ptr(args...)
    }

    void handle(function<R(Args...)> func) {
        cout << "Handling function with return type " << typeid(R).name()
                  << " and arguments: ";
        cout << " (function)" << endl;
    }
};

// A sample function for demonstration
int add(int a, int b) {
    return a + b;
}

void greet(const string& name) {
    cout << "Hello, " << name << "!" << endl;
}

int main() {
    // Generic type handling
    FunctionHandler<int> intHandler;
    intHandler.handle(10);

    FunctionHandler<string> stringHandler;
    stringHandler.handle("test");

    // Function pointer handling
    FunctionHandler<int(int, int)> addHandler;
    addHandler.handle(&add);

    //function handling
    function<void(const string&)> greetFunc = greet ;
    FunctionHandler<void(const string&)> greetHandler;
    greetHandler.handle(greetFunc);

    return 0;
}