_EXPORT_STD template <class _Ty, class _Dx /* = default_delete<_Ty> */>
class unique_ptr { // non-copyable pointer to an object
public:
    using pointer      = typename _Get_deleter_pointer_type<_Ty, remove_reference_t<_Dx>>::type;
    using element_type = _Ty;
    using deleter_type = _Dx;

_EXPORT_STD template <class _Ty, class _Dx = default_delete<_Ty>>
class unique_ptr;

template <class _Ty, class _Dx>
class unique_ptr
{
// ...
private:
    template <class, class>
    friend class unique_ptr;
};

Класс по умолчанию имеет доступ к своим приватным членам без необходимости объявления friend class для себя. В данном случае, добавление friend class unique_ptr внутри класса unique_ptr является излишним и необязательным.

Вероятно, это было сделано по ошибке или по недоразумению. Добавление friend class unique_ptr внутри класса unique_ptr не имеет реальной практической пользы и может быть удалено без влияния на функциональность класса.

using my_ptr = std::unique_ptr<some_type>;
using my_map = std::map<bool, my_ptr>;

my_map v_map;
v_map.try_emplace(true, std::in_place_type<some_type>); // Жалко, что так нельзя!
v_map.try_emplace(true, std::make_unique<some_type>() ); // Так можно, но увы лишнее создание объектов может произойти!

S>v_map.try_emplace(true, std::in_place_type<some_type>); // Жалко, что так нельзя!
S>

class Outer
{
public:
  
    Outer(int i, double d, const std::string& s)
        : m_inner(std::make_unique<Inner>(i, d, s)) { }

private:
    struct Inner
    {
        int i{};
        double d{};
        std::string s{};
   };

   std::unique_ptr<Inner> m_inner;
};


void foo()
{
    std::map<int, Outer> m;
    
    m.emplace(
        std::piecewise_construct,
        std::forward_as_tuple(1),
        std::forward_as_tuple(42, 3.14, "Hello")
    );
}

S>>v_map.try_emplace(true, std::in_place_type<some_type>); // Жалко, что так нельзя!
S>>

R>class Outer
R>{
R>public:
  
R>    Outer(int i, double d, const std::string& s)
R>        : m_inner(std::make_unique<Inner>(i, d, s)) { }

R>private:
R>    struct Inner
R>    {
R>        int i{};
R>        double d{};
R>        std::string s{};
R>   };

R>   std::unique_ptr<Inner> m_inner;
R>};


R>void foo()
R>{
R>    std::map<int, Outer> m;
    
R>    m.emplace(
R>        std::piecewise_construct,
R>        std::forward_as_tuple(1),
R>        std::forward_as_tuple(42, 3.14, "Hello")
R>    );
R>}
R>

void foo()
{
    std::map<int, Outer> m;
    
    m.try_emplace(1, 42, 3.14, "Hello");
}

#include <map>
#include <memory>
#include <iostream>

int main()
{
    std::map<int, std::unique_ptr<int>> map;

    struct Maker
    {
        operator std::unique_ptr<int>()
        {
            std::cout << "Maker activated" << std::endl;
            return std::make_unique<int>(220);
        }
    };

    map.try_emplace(1, Maker{});
    map.try_emplace(1, Maker{});

    return 0;
}

template <typename T, typename...A>
class Maker
{
public:

    explicit Maker(A&&...args) : m_args(std::forward<A>(args)...) {}

    operator std::unique_ptr<T>() &&
    {
        return std::apply(std::make_unique<T, A&&...>, std::move(m_args));
    }

private:

    std::tuple<A&&...> m_args;
};

template <typename T, typename... A>
Maker<T, A...> maker(A&&...args) { return Maker<T, A...>{ std::forward<A>(args)...}; }

#include <map>
#include <memory>

// библиотечный слой
template <class F>
struct Factory
{
    F f;
    operator auto()
    {
        return f();
    }
};

// прикладной
int main()
{
    std::map<int, std::unique_ptr<int>> map;

    map.try_emplace(1, Factory{[](){ return std::make_unique<int>(220);}});
    map.try_emplace(1, Factory{[](){ return std::make_unique<int>(380);}});

    return 0;
}

template <typename F>
class Maker
{
public:

    explicit Maker(F&& f) : m_f(std::forward<F>(f)) {}

    operator auto() && { return m_f(); }

private:

    F m_f;
};

template <typename F>
Maker(F&&) -> Maker<F>;

template <typename T, typename... A>
auto unique_maker(A&&...args) { return Maker([&]{ return std::make_unique<T>(std::forward<A>(args)...); }); }