// pair class definition

template <class T, class U>
class pair
{
		T m_left;
		U m_right;
	
	public:
		pair();
		pair(const T& t, const U& u);
		const T& left() const;
		T& left();
		const U& right() const;
		U& right();
		pair& operator+=(const pair& other);
};

template <class T, class U>
pair<T, U> operator+(const pair<T, U>& a, const pair<T, U>& b);

// traits class to indicate whether we should use + instead of += to add m_left and m_right

struct use_plusequals {};
struct use_plus {};

template <class T>
struct my_operator_traits
{
	typedef use_plusequals addition;
};

// pair class implementation

template <class T, class U>
pair<T, U>::pair()
{
}

template <class T, class U>
pair<T, U>::pair(const T& t, const U& u) : m_left(t), m_right(u)
{
}

template <class T, class U>
const T& pair<T, U>::left() const
{
	return m_left;
}

template <class T, class U>
T& pair<T, U>::left()
{
	return m_left;
}

template <class T, class U>
const U& pair<T, U>::right() const
{
	return m_right;
}

template <class T, class U>
U& pair<T, U>::right()
{
	return m_right;
}


// helper functions for delegating addition of left or right
template <class T, class U> void pair_add_left(pair<T, U>& p, const pair<T, U>& q, use_plusequals);
template <class T, class U> void pair_add_left(pair<T, U>& p, const pair<T, U>& q, use_plus);
template <class T, class U> void pair_add_right(pair<T, U>& p, const pair<T, U>& q, use_plusequals);
template <class T, class U> void pair_add_right(pair<T, U>& p, const pair<T, U>& q, use_plus);

template <class T, class U>
pair<T, U>& pair<T, U>::operator+=(const pair& other)
{
	// to write the pair class simply, just use the following two statements
	// m_left += other.m_left;
	// m_right += other.m_right;
	
	// the following two lines dispatch to the appropriate function depending on whether we want it to use + or +=
	pair_add_left(*this, other, typename my_operator_traits<T>::addition());
	pair_add_right(*this, other, typename my_operator_traits<U>::addition());
	return *this;
}

template <class T, class U>
pair<T, U> operator+(const pair<T, U>& a, const pair<T, U>& b)
{
	pair<T, U> dup(a);
	dup += b;
	return dup;
}

template <class T, class U>
void pair_add_left(pair<T, U>& p, const pair<T, U>& q, use_plusequals)
{
	p.left() += q.left();
}

template <class T, class U>
void pair_add_left(pair<T, U>& p, const pair<T, U>& q, use_plus)
{
	p.left() = p.left() + q.left();
}

template <class T, class U>
void pair_add_right(pair<T, U>& p, const pair<T, U>& q, use_plusequals)
{
	p.right() += q.right();
}

template <class T, class U>
void pair_add_right(pair<T, U>& p, const pair<T, U>& q, use_plus)
{
	p.right() = p.right() + q.right();
}