What is mutex_wrapped?

In this tutorial they state:

> A strong reason to use generic lambdas is for visiting syntax.
>
> boost::variant<int, double> value;
> apply_visitor(value, [&](auto&& e){
> std::cout << e;
> });
>
> Here we are visiting in a polymorphic manner; but in other contexts,
> the names of the type we are passing isn't interesting:
>
> mutex_wrapped<std::ostream&> os = std::cout;
> os.write([&](auto&& os){
> os << "hello world\n";
> });
>
> Repeating the type of std::ostream& is noise here; it would be like
> having to mention the type of a variable every time you use it. Here
> we are creating a visitor, but no a polymorphic one; auto is used for
> the same reason you might use auto in a for(:) loop.

First of all I could not get the above example to work with out swapping the operands around:

boost::variant<int, double> value;
boost::apply_visitor(
    [&](auto&& e){
        std::cout << e;
    },
    value
);

I suppose this could be due to changes to boost since the tutorial was written.

But for the second example I cannot yet find from where mutex_wrapped comes, and I do not understand what write(lambda) will do, it seems to me that write() requires const char* s, streamsize n.

Is this second example purely imaginary as in mutex_wrapped is an imaginary class that has a write method that takes a lambda and executes the lambda using the wrapped stream as the parameter?

Declaimer of that site:

> This Tutorial is compiled from StackOverflow Documentation, the content is written by the brilliant people at Stack Overflow.

Googling trough StackOverflow gave me that posted answer: https://stackoverflow.com/a/59601498/6752050. It defined shared_mutex_wrapped but the example used it as mutex_wrapped, it might be a typo. Let's name it mutex_wrapped:

template<class T>
struct mutex_wrapped {
  mutex_wrapped(T t) : t(t) {}  // Was missing in the original post

  template<class F>
  auto read( F&& f ) const {
    auto l = lock();
    return f(t);
  }

  template<class F>
  auto write( F&& f ) {
    auto l = lock();
    return f(t);
  }

private:
  mutable std::shared_mutex m;
  T t = {};
  auto lock() const { return std::shared_lock< std::shared_mutex >( m ); }
  auto lock() { return std::unique_lock< std::shared_mutex >( m ); }
};

The Wrapper needs a generic constructor to assign it's internal type T, t variable. Here's a complete corrected example:

#include <iostream>
#include <mutex>
#include <shared_mutex>
    
template<class T>
struct mutex_wrapped {
    explicit mutex_wrapped(T t) : t(t) {}

    template<class F>
    auto read( F&& f ) const {
        auto l = lock();
        return f(t);
    }
    template<class F>
    auto write( F&& f ) {
        auto l = lock();
        return f(t);
    }
private:
    mutable std::shared_mutex m;
    T t = {};
    auto lock() const { return std::shared_lock< std::shared_mutex >( m ); }
    auto lock() { return std::unique_lock< std::shared_mutex >( m ); }
};

int main() {
    mutex_wrapped<std::ostream&> os(std::cout);
    os.write([&](auto&& os){
        os << "hello world\n";
    });

    return 0;
}