Is it necessary to use std::move when swapping two objects?

std::function::swap does not take its parameter by rvalue reference. It's just a regular non-const lvalue reference. So std::move is unhelpful (and probably shouldn't compile, since rvalue references aren't allowed to bind to non-const lvalue references).

other_function also doesn't need to be an rvalue reference.

The signature is

void std::function<Sig>::swap( function& other )

so code should not compile with std::move (msvc has extension to allow this binding :/)

As you take r-value reference, I think that a simple assignment is what you want in your case:

std::function<void(int)> my_std_function;

void call(std::function<void(int)>&& other_function)
{
  my_std_function = std::move(other_function); // Move here to avoid copy
}

In this case, it doesn't make a difference as std::function::swap takes a non-const lvalue reference. It shouldn't even compile with std::move.

If you used a function which did allow rvalues, then you would need to call std::move as other_function is an lvalue, even though the type of it is an rvalue reference. For example:

struct Foo {
    Foo()=default;
    Foo(const Foo&) { std::cout << "copy" << std::endl; }
    Foo(Foo&&) { std::cout << "move" << std::endl; }
};

void bar (Foo&& a) {
    Foo b {a};            //copy
    Foo c {std::move(a)}; //move
}

You are right in a sense — to get an rvalue again you'd need std::move.

However, the swap call doesn't need an rvalue or an rvalue reference — just a plain ol' lvalue ref.

So you're good to go without the std::move cast.

In terms of move semantics, a swap operation is pretty low-level. You'll find that most useful moves are ultimately implemented by a series of swaps, so it makes sense that the swaps themselves don't use move semantics. Really, how would they?