#pragma once

/*
 *  functional.h
 *  Picross
 *
 */

#include <vector>

template <class _TArg1, class _TArg2, class _TRet>
class binfunc {
public:
	virtual _TRet operator()(_TArg1 &, _TArg2 &) = 0;
};

template <class _TArg, class _TRet>
class unfunc {
public:
	virtual _TRet operator()(_TArg &) = 0;
};

template <class _TA, class _TB>
class couple {
public:
	couple(_TA a, _TB b) : m_a(a), m_b(b) { }
	
	bool operator<(const couple<_TA, _TB> &other) const {
		if (m_a==other.m_a) {
			return m_b<other.m_b;
		} else {
			return m_a<other.m_a;
		}
	}
private:
	_TA m_a;
	_TB m_b;
};

template <class _TA, class _TB>
couple<_TA, _TB> makecouple(_TA a, _TB b) {
	return couple<_TA, _TB>(a, b);
}


template <class _TA, class _TB, class _TC>
class triplet {
public:
	triplet(_TA a, _TB b, _TC c) : m_a(a), m_b(b), m_c(c) { }
	bool operator==(const triplet<_TA, _TB, _TC> &other) {
		return other.m_a==m_a && other.m_b==m_b && other.m_c==m_c;
	}
private:
	_TA m_a;
	_TB m_b;
	_TC m_c;
};

template <class _TA, class _TB, class _TC>
triplet<_TA, _TB, _TC> maketrip(_TA a, _TB b, _TC c) {
	return triplet<_TA, _TB, _TC>(a, b, c);
}	

template <class _TList>
std::vector<_TList> filter(std::vector<_TList> &ls, unfunc<_TList, bool> &fn) {
	std::vector<_TList> lr;

	for (int i=0;i<ls.size();i++) {
		if (fn(ls[i])) {
			lr.push_back(ls[i]);
		}
	}
	
	return lr;
}

template <class _TList>
_TList reduce(std::vector<_TList> &ls, binfunc<_TList, _TList, _TList> &fn) {
	if (ls.size()==1) {
		return ls[0];
	}
	
	_TList tmp = fn(ls[0], ls[1]);
	for (int i=0;i<ls.size();i++) {
		tmp = fn(tmp, ls[i]);
	}
	
	return tmp;
}