Get base class target from std::function

If I store a polymorphic functor in an std::function, is there a way to extract the functor without knowing the concrete type?

Here is a simplified version of the code:

class Base {
    ...
    virtual int operator()(int foo) const = 0;
    void setBar(int bar);
}
class Derived : public Base {
    ...
    int operator()(int foo) const override;
}

std::function<int(int)> getFunction() {
    return Derived();
}

int main() {
    auto f = getFunction();
    // How do I call setBar() ?
    if (Base* b = f.target<Base>()) {} // Fails: returns nullptr
    else if(Derived* d = f.target<Derived>()) {
        d->setBar(5); // Works but requires Derived type
    }
    std::cout << f(7) << std::endl;
    return 0;
}

I want the client to be able to provide their own function, and for my handler to use the functionality of the Base if it's available.

The fall back would be of course to just use the abstract base class instead of std::function and clients would implement the ABC interface as they would have pre-C++11:

std::shared_ptr<Base> getFunction {
    return std::make_shared<Derived>();
}

but I wanted to know if it's possible to create a more flexible and easier to use interface with C++14. It seems all that's missing is a cast inside std::function::target