wow thx, it is very useful!!

Auto comment: topic has been translated by bogorodniy (original revision, translated revision, compare)

very cool!

Some time ago I wrote

/*
/in/ shortcut
+ 2 in [1,2,3]
+ "ab" in "bacaba"
+ 'w' in "cow"
+ "key" in {"key": 123}_json
+ 42 in map<int, string>, set<int> (+unordered)
*/
namespace ultra {
    template<typename T>
    struct in_prefix_t {
        T const *pvalue = nullptr;
        explicit inline in_prefix_t(T const *pvalue) : pvalue(pvalue) { }
    };
    struct in_helper_t { };

} // namespace ultra

ultra::in_helper_t in;

template<typename T>
inline ultra::in_prefix_t<T> operator / (T const& value, ultra::in_helper_t) {
    return ultra::in_prefix_t<T>(&value);
}

template<typename T, typename Container>
inline bool operator / (ultra::in_prefix_t<T> prefix, Container const& cont) {
    return std::find(std::begin(cont), std::end(cont), *prefix.pvalue) != std::end(cont);
}

template<typename T>
inline bool operator / (ultra::in_prefix_t<T> prefix, std::string const& s) {
    return s.find(*prefix.pvalue) != string::npos;
}

inline bool operator / (ultra::in_prefix_t<char> prefix, std::string const& s) {
    return s.find(*prefix.pvalue) != string::npos;
}

template<typename T, typename U, typename V>
inline bool operator / (ultra::in_prefix_t<T> prefix, std::map<U, V> const& m) {
    return m.find(*prefix.pvalue) != m.end();
}

template<typename T, typename U>
inline bool operator / (ultra::in_prefix_t<T> prefix, std::set<U> const& s) {
    return s.find(*prefix.pvalue) != s.end();
}

template<typename T, typename U, typename V>
inline bool operator / (ultra::in_prefix_t<T> prefix, std::unordered_map<U, V> const& m) {
    return m.find(*prefix.pvalue) != m.end();
}

template<typename T, typename U>
inline bool operator / (ultra::in_prefix_t<T> prefix, std::unordered_set<U> const& s) {
    return s.find(*prefix.pvalue) != s.end();
}

template<typename T>
inline bool operator / (ultra::in_prefix_t<T> prefix, json s) {
    return s.count(*prefix.pvalue) != 0;
}

Pretty useless although :)

Interesting idea, execution leaves much to be desired.

1) You shouldn't put int& as the parameter type for operator>>, int will do just fine. In fact, you'll get compilation errors if you try to use an r-value as an operand, as in the example below.

2) After replacing int& with int, what does this print?

int computeSomething() {
	int z = 1000;
	z minEqual 100;
	return z;
}

signed main() {
  int x = 200, y = 300;
  y minEqual computeSomething();
  cout << x << ' ' << y << endl;
}

I made it a bit shorter (and also without bug, which ivan100sic mentioned)

struct X {
    int *t;
};

X operator ^ (int &a, X x) {
    x.t = &a;
}

void operator ^ (X x, int b) {
    *(x.t) = min(*(x.t), b);
}

#define minEqual ^X()^

And this can be improved to work with any type:

template<typename T>
struct X {
    T *t;
};
template<typename T>
void operator ^ (X<T> x, T b) {
    *(x.t) = min(*(x.t), b);
}

struct Y {
};

template<typename T>
X<T> operator ^ (T &a, Y y) {
    X<T> res;
    res.t = &a;
    return res;
}

#define minEqual ^Y()^

Actually, it is better to use operator ,, instead of operator ^ to avoid extra brackets (link)

By the way, my code creates structure on each minEqual, so probably it is slower than the original version, but I am not sure. However, if you aim for speed, you shouldn't use any of these options, I think.

I suppose that I write x minEqual f(1, 2, 3); to minimize x by a result of function call f(1, 2, 3). Obviously it 1) will not compile and 2) might lead to undefined behavior if f(int, int, int) uses minEqual operator as well.

So that I just return to simpler alternative:

void minimize(int& a, int b)
{
    a = std::min(a, b);
}
...
    minimize(x, f(1, 2, 3));
...

An I use

template<class _A_, class _B_>
void minimize(_A_ &_a_, _B_ _b_) { if (_a_ > _b_) _a_ = _b_; }
bool   ismini(_A_ &_a_, _B_ _b_) { if (_a_ > _b_) { _a_ = _b_; return true; } return false; }

And I use normal functions like these

/// I use _x_ instead of normal x to prevent from IntelliSense

/// a = min(a, b)
template<class _A_, class _B_>
void minimize(_A_ &_a_, const _B_ &_b_) { if (_a_ > _b_) _a_ = _b_; }

/// return true if (a is minimized to b)
template<class _A_, class _B_>
bool   ismini(_A_ &_a_, const _B_ &_b_) { if (_a_ > _b_) { _a_ = _b_; return true; } return false; }

/// a = min{b, ...}
template<class _A_, class _B_, class..._V_>
void minimize(_A_ &_a_, const _B_ &_b_, const _V_&..._v_) {
    minimize(_a_, _b_);
    minimize(_a_, _v_...);
}