talybin

#pragma once
#include <type_traits>
#include <tuple>
#include <memory>

template <std::size_t N, class... Types>
struct packed_tuple;

// is_packed_tuple
template <class T>

talybin

namespace detail
{
    template <class T>
    struct flag
    {
        struct dummy {
            constexpr dummy() {}

            #pragma GCC diagnostic push
            #pragma GCC diagnostic ignored "-Wnon-template-friend"

talybin

#include <iostream>
#include <ctime>
#include <utility>

template <class T, class F, T... I>
bool to_const(T value, F&& fn, std::integer_sequence<T, I...>) {
    return (
        (value == I && (fn(std::integral_constant<T, I>{}), true))
        || ... // or continue
    );

talybin

#include <type_traits>

template <class T, class = std::enable_if_t<std::is_integral<T>::value>>
using integral_t = T;

// the usage
template <class T>
void f(integral_t<T> a) {}

int main()

talybin

#include <iostream>

struct printer
{
    template <class T>
    constexpr void operator()(const T& t) const {
        std::cout << t << '\n';
    }
};

talybin

#include <iostream>
#include <functional>
#include <any>

struct any_type : std::any
{
    using std::any::any;
    template <class T> operator T() const {
        return std::any_cast<T>(*this);
    }

talybin

#pragma once
#include <utility>

template <class T, std::size_t... I>
inline const char* type_name(std::index_sequence<I...>) {
    static constexpr char name[] = { __PRETTY_FUNCTION__[I + 60]..., 0 };
    return name;
}

template <class T>

talybin

#include <iostream>
#include <string_view>

template <class T>
constexpr std::string_view type_name(const T&)
{
    std::string_view sv = __PRETTY_FUNCTION__;

    sv.remove_prefix(sv.find('=') + 2);
    return { sv.data(), sv.find(';') };

talybin

#pragma once
#include <string>

namespace ard
{
    namespace detail
    {
        // Type to format mapping
        template <class T> constexpr nullptr_t type_fmt {};
        using fmt_t = const char[];

talybin

#include <iostream>

template <class T> struct overload : T { using T::operator(); };
template <class T> overload(T) -> overload<T>;

int main()
{   
    auto f = [x = 1, y = 2]() { return x + y; };
    // auto [a, b] = f; // error: cannot decompose lambda closure type 'main()::<lambda()>'