#include <array>
#include <tuple>
using namespace std;

struct Q {
    void set(int i) {}
};

template <int I>
struct S {
    Q mq[I];
    template <size_t ...num>
    void f(array<int, I> &a,
            index_sequence<num...> n=make_index_sequence<I>{}) {
        ((mq[num].set(a[num])), ...);
    }
};

int main() {
    S<3> s;
    array a{2, 5, 7};
    s.f(a);
}

	template <size_t ...num>
	void f_ok(array<int, I> &a) {
		f(a, make_index_sequence<I>{});
	}

#include <boost/locale.hpp>
#include <iostream>
#include <string>
#include <locale>
using namespace boost::locale;
using namespace std;
 
int main() {
	wstring str = L"фыва\u00b4"; // "фыва" с ударением на 'а'
	generator gen;
	locale::global(gen(""));
	wstring res = normalize(str, boost::locale::norm_nfd);
	fold_case(res);
	cout << str.size() << "  " << res.size() << endl;
}

// cout: 5 5

char translate(wchar_t sym);
cout << translate(L'й')
     << translate(L'ц')
     << translate(L'у')
     << translate(L'к')
     << translate(L'е')
     << translate(L'н');
// cout: qwerty

#include <tuple>
#include <type_traits>
using namespace std;

template <typename Tuple, size_t i=0>
requires (i >= tuple_size_v<Tuple>)
consteval bool check_visitor() {
	return true;
}

template < typename Tuple, size_t i=0>
requires (i < tuple_size_v<Tuple>)
consteval bool check_visitor() {
	static_assert(! is_same_v<tuple_element_t<i, Tuple>, bool>);
	return check_visitor<Tuple, i+1>();
}

int main() {
	using T = tuple<int, double, char>;
	check_visitor<T>();
}

#include <tuple>
#include <type_traits>
using namespace std;

template < typename Tuple, size_t i=0>
consteval bool check_visitor() {
	static_assert(! is_same_v<tuple_element_t<i, Tuple>, bool>);
	if constexpr (i < tuple_size_v<Tuple>)
		return check_visitor<Tuple, i+1>();
	else
		return true;
}

int main() {
	using T = tuple<int, double, char>;
	check_visitor<T>();
}

function Clear_terminal()
	if winnr('$') == 1
		let l:only_window = 1
	else
		let l:only_window = 0
	endif
	bd!
	terminal
	if only_window
		only
	endif
endfunction

function Terminal_started()
	setlocal nonumber
	nmap <buffer> <C-w>l :call Clear_terminal()<CR>
endfunction

augroup Mode_hooks_group
	autocmd!
	...
	autocmd TerminalOpen * call Terminal_started() 
augroup End

tmap <C-w>l <C-w>N<C-w>l "выход в нормальный режим, а следом ввод <C-w>l для вызова функции

$ dog www.wikipedia.org
CNAME www.wikipedia.org.  23h59m10s   "dyna.wikimedia.org."
    A dyna.wikimedia.org.     9m10s   91.198.174.192
$ ping 91.198.174.192
PING 91.198.174.192 (91.198.174.192) 56(84) bytes of data.
64 bytes from 91.198.174.192: icmp_seq=1 ttl=58 time=144 ms

#include <thread>
#include <atomic>
#include <mutex>
#include <vector>
#include <chrono>
using namespace std;

class Test {
	mutex m_mtx;
	atomic_flag m_spin_lock;
	vector<int> m_data;
public:
	void add() {
		while (m_spin_lock.test_and_set(memory_order_relaxed))
			this_thread::yield();
		atomic_thread_fence(memory_order_acquire);
		while (true) {
			this_thread::sleep_for(300ms);
			std::scoped_lock lck{m_mtx};
			m_data.push_back(4);
		}
		m_spin_lock.clear(memory_order_release);
	}
	void read() {
		size_t sz;
		while (true) {
			if (! m_spin_lock.test_and_set(std::memory_order_acquire)) {
				sz = m_data.size();
				m_spin_lock.clear(std::memory_order_release);
			}
			else {
				std::scoped_lock lck{m_mtx};
				sz = m_data.size();
			}
			this_thread::sleep_for(1s);
		}
	}
}test;

int main() {
	jthread rt(&Test::read, &test);
	this_thread::sleep_for(10ms);
	test.add();
}

$ g++ 1.cc -std=c++20 -fsanitize=thread
$ ./a.out
WARNING: ThreadSanitizer: data race (pid=63269)
  Write of size 8 at 0x56247be53a80 by main thread (mutexes: write M11):
    #0 void std::vector<int, std::allocator<int> >::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int> > >, int&&) <null> (a.out+0xd9a47)
    #1 int& std::vector<int, std::allocator<int> >::emplace_back<int>(int&&) <null> (a.out+0xd970c)
    #2 std::vector<int, std::allocator<int> >::push_back(int&&) <null> (a.out+0xd9595)
    #3 Test::add() <null> (a.out+0xd819b)
    ...

  Previous read of size 8 at 0x56247be53a80 by thread T1:
    #0 std::vector<int, std::allocator<int> >::size() const <null> (a.out+0xd899d)
    #1 Test::read() <null> (a.out+0xd7bc2)
    ...

#include <mutex>
#include <thread>
#include <chrono>
#include <condition_variable>
#include <queue>
#include <memory>
using namespace std;

struct Mes {
	int data = 0;
	bool processed = false;
};

struct Test {
	mutex mtx;
	condition_variable cv;
	queue<weak_ptr<Mes>> mes_queue;
	int read();
	bool check();
} t;

int Test::read()
{
	auto sh_ptr = make_shared<Mes>();
	unique_lock lck{mtx};
	mes_queue.push(sh_ptr);
	while (! cv.wait_for(lck, 1s, [&sh_ptr](){
				return sh_ptr->processed == true;})  &&  true);
	return sh_ptr->data;
}

bool Test::check()
{
	scoped_lock lck{mtx};

	bool ret = mes_queue.size();
	while (mes_queue.size()) {
		if (shared_ptr<Mes> mes = mes_queue.front().lock()) {
			mes->data = 5;
			mes->processed = true;
		}
		mes_queue.pop();
	}
	cv.notify_all();
	return ret;
}

void read_th() {
	while (true) {
		t.read();
		this_thread::sleep_for(200ms);
	}
}

void check_th() {
	while (true) {
		t.check();
		this_thread::sleep_for(200ms);
	}
}

int main() {
	jthread tr{read_th};
	jthread tc{check_th};
}

$ g++ -pthread -std=c++20 -fsanitize=thread test.cc

operator[]( ptrdiff_t pos );

template <typename T>
auto &idx(T &container, std::ptrdiff_t i) {
    return container[static_cast<std::size_t>(i)];
}

template <size_t Sz>
struct S {
   S(...);
};

int main() {
   array<int, 5> a;
   S s{ {1,2,3} };
   S s2(a);
}

#include <array>
#include <initializer_list>
using namespace std;

template <size_t U>
struct S {
   S(array<int, U>) {}
};
S(initializer_list<int> l) -> S<l.size()>; // error, можно просто 3, тогда ок, в данном случае

int main() {
   S s2{ {3,4,5} };
}

template <size_t U>
struct S {
    S(const int(&ar)[U]) {}
};

int main() {
   array<int, 5> a;
   S s2{ {3,4,5} }; #1
   S s2(a);         #2 error
}

template <typename T>
struct Return_type;
template <typename R, typename... Args>
struct Return_type<R(Args...)> {using type = R;};
template <typename R, typename Q, typename... Args>
struct Return_type<R (Q::*)(Args...)const> {using type = R;};
template <typename R, typename Q, typename... Args>
struct Return_type<R (Q::*)(Args...)> {using type = R;};

struct A{
	struct V {
		double operator()(int t)const {return 5;}
	};
};

int main() {
	auto l = [](double a, int e)mutable{return 2;};
	auto l2 = [](int a){;return 2;};
	Return_type<decltype(&decltype(l)::operator())>::type a;
	Return_type<decltype(&decltype(l2)::operator())>::type a2;
	Return_type<decltype(&A::V::operator())>::type a3;


	auto l3 = [](auto b){;return 2;};
	Return_type<decltype(&decltype(l3)::operator())>::type a4;

	return 0;
}

    wchar_t w = L'\u2028';
    cout << std::boolalpha 
        << std::iscntrl(w, boost::locale::generator()("en_US.UTF-8")) << endl
        << std::iscntrl(w, std::locale("en_US.UTF-8")) << endl;

$ ./a.out
false
true