How about using the ternary operator? It will automatically deduce the correct optional type

#include <optional>
auto foo(bool b) {
  return b ? std::nullopt : std::optional{[](int){}};
}

You can add a level of indirection to deduce the type via auto and decltype:

#include <optional>

auto foo_impl(){
    return [](int){};
}

std::optional<decltype(foo_impl())> foo(bool b) {
    if(b) return std::nullopt;
    return foo_impl();
}

You can do it something like the following

#include <iostream>
#include <optional>

auto f( bool b )
{
    auto l = [] { std::cout << "Hello World!";  };
    std::optional<decltype( l )> opt;

    if (b)
    {
        // some code
        opt = l;
    }
    else
    {
        // some other cod
    }

    return opt;
}

int main()
{
    ( *f( true  ) )( );
}

Another way is to use std::function with std::optional as for example

std::optional<std::function<void( int )>> g( bool b )
{
    if (b)
    {
        return std::function<void( int )>( []( int x ) { std::cout << x;  } );
    }
    else
    {
        return std::function<void( int )>( []( int x ) { std::cout << 2 * x; } );
    }
}