fork download

copy

#include <iostream>
#include <tuple>
 
template<class T, class F>
class predicate {
public:
    explicit predicate(T const& t, F const& p = F())
    : value(t)
    , pred(f) {}
 
    bool match(T const& value2) {
        return pred(value, value2);
    }
 
private:
    T value;
    F pred;
};
 
template<class T>
struct __op_eq {
    operator()(T const& a, T const& b) {
        return a == b;
    }
};
 
template<class T>
struct __op_gt {
    operator()(T const& a, T const& b) {
        return a > b;
    }
};
 
template<class T> using eq_pred = predicate<T, op_eq<T>>;
template<class T> using gt_pred = predicate<T, op_gt<T>>;
 
template<class... Ts>
class __match {
public:
    template<class... Us>
    __match(Us&&... argz) : args(argz...) {}
 
    template<class U, class Us...>
    match& operator=(std::tuple<U, Us...> t) {
        do_match<0>(t);
        do_assign<0>(t);
        return *this;
    }
 
private:
    void do_match(std::tuple<> const&) {}
 
    template<std::size_t I, class U, class... Us>
    void do_match(std::tuple<U, Us...> const& tup) {
        do_match<I + 1>(std::tail(tup));
    }
 
    template<std::size_t I, class U, class... Us, class V, class W>
    void do_match(std::tuple<predicate<V, W>, Us...> const& tup) {
        if (!std::get<0>(tup).match(std::get<I>(args))) {
            throw match_error{};
        }
 
        do_match<I + 1>(std::tail(tup));
    }
 
    void do_assign(std::tuple<> const&) {}
 
    template<std::size_t I, class U, class... Us>
    void do_assign(std::tuple<U, Us...> tup) {
        std::get<0>(tup) = std::get<I>(args);
        do_assign<I + 1>(std::tail(tup));
    }
 
    template<std::size_t I, class U, class... Us, class V, class W>
    void do_assign(std::tuple<predicate<V, W>, Us...> const& tup) {
        do_assign<I + 1>(std::tail(tup));
    }
 
    std::tuple<Ts&...> args;
};
 
template<class... Ts>
__match<Ts...> match(Ts&&... ts) {
    return __match<Ts...>{ts...};
}
 
int main() {
    int a, b, c;
    match(a, b, eq_pred{42}, c) = std::make_tuple(1, 2, 42, 3);
    std::cout << a << ", " << b << ", " << c << '\n';
 
    match(a, b, eq_pred{43}, c) = std::make_tuple(1, 2, 42, 3);
    std::cout << a << ", " << b << ", " << c << '\n';
}
 

prog.cpp: In constructor 'predicate<T, F>::predicate(const T&, const F&)':
prog.cpp:9:12: error: 'f' was not declared in this scope
prog.cpp: At global scope:
prog.cpp:22:38: error: ISO C++ forbids declaration of 'operator()' with no type
prog.cpp:29:38: error: ISO C++ forbids declaration of 'operator()' with no type
prog.cpp:34:19: error: expected unqualified-id before 'using'
prog.cpp:35:19: error: expected unqualified-id before 'using'
prog.cpp:43:31: error: 'struct Us' is not a valid type for a template constant parameter
prog.cpp:44:5: error: 'match' does not name a type
prog.cpp:50:1: error: expected unqualified-id before 'private'
prog.cpp: In member function 'void __match<Ts>::do_match(const std::tuple<U, Us ...>&)':
prog.cpp:55:25: error: 'tail' is not a member of 'std'
prog.cpp: In member function 'void __match<Ts>::do_match(const std::tuple<predicate<V, W>, Us ...>&)':
prog.cpp:61:19: error: 'match_error' was not declared in this scope
prog.cpp:61:30: error: expected ';' before '{' token
prog.cpp:64:25: error: 'tail' is not a member of 'std'
prog.cpp: In member function 'void __match<Ts>::do_assign(std::tuple<U, Us ...>)':
prog.cpp:72:26: error: 'tail' is not a member of 'std'
prog.cpp: In member function 'void __match<Ts>::do_assign(const std::tuple<predicate<V, W>, Us ...>&)':
prog.cpp:77:26: error: 'tail' is not a member of 'std'
prog.cpp: In function 'int main()':
prog.cpp:90:17: error: 'eq_pred' was not declared in this scope
prog.cpp:93:24: error: expected ')' before '{' token

Standard output is empty