1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93
94. 94
95. 95
96. 96
97. 97
98. 98
99. 99
100. 100

struct any
    {
        std::any _val;

        inline constexpr any() : _val{}
        {
        }

        inline constexpr any(undefined_t) noexcept : _val{}
        {
        }

        inline constexpr any(std::nullopt_t) noexcept : _val{}
        {
        }

        template <typename T>
        inline constexpr any(const T &val) : _val{val}
        {
        }

        inline any(const any &val) noexcept : _val{val._val}
        {
        }

        inline any(any &&val) noexcept : _val{std::move(val._val)}
        {
        }

        inline any &operator=(const any &val)
        {
            _val = val._val;
            return *this;
        }

        inline operator bool()
        {
            if (!_val.has_value())
            {
                return false;
            }

            auto type_index = std::type_index(_val.type());
            if (type_index == std::type_index(typeid(int)))
            {
                return std::any_cast<int>(_val) > 0;
            }
            else if (type_index == std::type_index(typeid(double)))
            {
                return std::any_cast<double>(_val) > 0;
            }
            else if (type_index == std::type_index(typeid(tstring)))
            {
                return std::any_cast<tstring>(_val).size() > 0;
            }
            else if (type_index == std::type_index(typeid(tstring_view)))
            {
                return std::any_cast<tstring_view>(_val).size() > 0;
            }
            else if (type_index == std::type_index(typeid(const char_t *)))
            {
                auto v = std::any_cast<const char_t *>(_val);
                return !v;
            }
            else if (type_index == std::type_index(typeid(std::nullptr_t)))
            {
                return false;
            }
            else if (type_index == std::type_index(typeid(bool)))
            {
                return std::any_cast<bool>(_val);
            }

            return true;
        }

        template <typename N = void>
        requires Arithmetic<N> any operator+(N n)
        {
            return any{std::any_cast<N>(this->_val) + n};
        }

        friend std::ostream &operator<<(std::ostream &os, const any &val_)
        {
            auto val = val_._val;
            if (val.has_value())
            {
                auto type_index = std::type_index(val.type());
                if (type_index == std::type_index(typeid(int)))
                {
                    os << std::any_cast<int>(val);
                }
                else if (type_index == std::type_index(typeid(double)))
                {
                    os << std::any_cast<double>(val);
                }
                else if (type_index == std::type_index(typeid(tstring)))
                {
                    os << std::any_cast<tstring>(val);
                }