enum class Mode : unsigned {
    UP,
    DOWN
};

bool operator! (Mode mode)
{
  return Mode::UP != mode;
}

 Mode mode = ...;
 if ( !! mode )

class Foo
{
    typedef bool (Foo::*UnspecifiedBool)() const;
public:
    bool empty() const;
    operator UnspecifiedBool() const { !empty() ? &Foo::empty : 0; }
};

if (!! (a & b) )
{
    // ...
}

enum class Flags : unsigned {};

constexpr Flags one = 1;
constexpr Flags two = 2;
constexpr Flags one = 4;

enum class Flag : unsigned
{
  Up = 1, Down=2, Left=4, Right=8
};

struct FlagSet
{
  unsigned m_set;
  explicit FlagSet(Flag flag) { m_set = flag;}  // иногда набор состоит из одного флага
  explicit FlagSet(unsigned set) : m_set(set){} // возможно этот конструктор нужно сделать приватным, а некоторые операторы сделать друзьями
  // добавить конструкторов при необходимости


  operator bool() // todo: bool safe idiome
  {
    return 0 == set; // return true 
  }  
};

// объединение флагов дают набор
FlagSet operator | (Flag flag1, Flag flag2)
{
  return (unsigned)flag1 | (unsigned)flag2;
}

// объединение наборов дают набор
FlagSet operator | (FlagSet mod1, FlagSet mod2)
{
  return mod1.m_set | mod2.m_set;
}

// пересечение наборов дают набор
FlagSet operator & (FlagSet mod1, FlagSet mod2)
{
  return mod1.m_set & mod2.m_set;
}

// пересечение набора и флага дают true если флаг присутствует в наборе
bool operator & (FlagSet mod, Flag flag)
{
  return mod.m_set & (unsigned) flag;
}

// пересечение набора и флага дают true если флаг присутствует в наборе
bool operator & (Flag flag, FlagSet mod)
{
  return mod & flag;
}

....

R>>enum class Flags : unsigned {};

R>>constexpr Flags one = 1;
R>>constexpr Flags two = 2;
R>>constexpr Flags one = 4;

R>>

enum class Flags : unsigned;

constexpr auto one = Flags(1);
constexpr auto two = Flags(2);
constexpr auto four = Flags(4);

#include <iostream>
#include <type_traits>
#include <utility>

template <typename T>
std::enable_if_t<std::is_enum_v<T>, std::underlying_type_t<T>> operator + (T e) {
    return std::underlying_type_t<T>(e);
}

template <typename T>
std::enable_if_t<std::is_enum_v<T>, std::underlying_type_t<T>> operator * (T e) {
    return +e;
}

enum class Flags : unsigned {
    one = 1,
    two = 2,
    four = 4,
};

int main() {
    if (+Flags::one)
        std::cout << "Ok" << std::endl;

    if (*Flags::two)
        std::cout << "Ok" << std::endl;
}

#include <iostream>
#include <cstdlib>
#include <utility>

enum class EE: unsigned
{
  asdf = 0, gkl = 1
};

int main() {
    // your code goes here
    
    EE x{9};
    
    return 0;
}

enum EE
{
  a, b, c, d
};

constexpr EE min = *std::min_element(std::begin<EE>(), std::end<EE>());

for(auto en : EE)
  m = std::max(m, en);

for(auto en : { EE... } )
  m = std::max(m, en);

BFE>enum EE
BFE>{
BFE>  a, b, c, d
BFE>};

BFE>constexpr EE min = *std::min_element(std::begin<EE>(), std::end<EE>());
BFE>

template<typename>
struct min_element;

template<typename T, T head, T...tail>
struct min_element<std::integer_sequence<T, head, tail...>> {
    static constexpr T value = std::min(head, min_element<std::integer_sequence<T, tail...>>::value);
};

template<typename T, T head>
struct min_element<std::integer_sequence<T, head>> {
    static constexpr T value = head;
};

enum EE {
    a, b, c, d
};
using EE_sequence = std::integer_sequence<EE, a, b, c, d>;

static_assert(a == min_element<EE_sequence>::value);

template<typename>
struct min_element;

template<typename T, T head, T...tail>
struct min_element<std::integer_sequence<T, head, tail...>> {
    static constexpr T value = std::min(head, min_element<std::integer_sequence<T, tail...>>::value);
};

template<typename T, T head>
struct min_element<std::integer_sequence<T, head>> {
    static constexpr T value = head;
};

enum class EE {
    a, b, c, d
};
using EE_sequence = std::integer_sequence<EE, EE::a, EE::b, EE::c, EE::d>;

static_assert(EE::a == min_element<EE_sequence>::value);

R>enum class EE {
R>    a, b, c, d
R>};
R>using EE_sequence = std::integer_sequence<EE, EE::a, EE::b, EE::c, EE::d>;

R>static_assert(EE::a == min_element<EE_sequence>::value);
R>

enum class EE {
    a, b, c, d, e = -1
};
using EE_sequence = std::integer_sequence<EE, EE::a, EE::b, EE::c, EE::d>;

static_assert(EE::a == min_element<EE_sequence>::value);

#include <type_traits>

template <typename T>
auto has_feature(T t, T f) -> bool
{ 
   return static_cast<std::underlying_type_t<T>>(t & f) != 0;
}

#include <type_traits>

template <typename T>
   requires 
    std::is_enum_v<T>
     && (T t, T f){ { t & f } -> T; }
auto has_feature(T t, T f) -> bool
{ 
   return static_cast<std::underlying_type_t<T>>(t & f) != 0;
}

#include <type_traits>
#include <concepts>

template <typename T>
   requires 
    (std::is_enum_v<T> || std::integral<T>)
     && (T t, T f){ { t & f } -> T; }
auto has_feature(T t, T f) -> bool
{ 
   return t & f != static_cast<T>(0);
}