#include <cassert>
#include <iterator>
#include <vector>
#include <string>
#include <list>
#include <set>

template <typename T, typename U>
auto add(T const& a, U const& b);

template <typename T, typename U>
auto add_helper(T const& a, U const& b, int, int)
    -> decltype( a + b )
{
    return a + b;
}

template <typename T, typename U>
auto add_helper(T const& a, U const& b, int, float)
    -> decltype( std::begin(a), std::begin(b), T{a} )
{
    T result { a };    
    auto it = std::begin(b);
    for (auto& element : result)
        element = add(element, *it++);
    return result;
}

template <typename T, typename U>
auto add_helper(T const& a, U const& b, float, float)
    -> decltype( std::begin(a), T{a} )
{
    T result { a };
    for (auto& element : result)
        element = add(element, b);
    return result;
}

template <typename T, typename U>
auto add(T const& a, U const& b)
{
    return add_helper(a, b, 0, 0);
}

int main()
{
    // Try some basic things
    assert(( add(1, 2) == 3 ));
    assert(( add(1.5, 2) == 3.5 ));
    assert(( add(1.5, 2.5) == 4.0 ));

    // Try with all vectors
    {
        std::vector<int> v1 { 1, 2, 3 };
        std::vector<int> v2 { 4, 5, 6 };
        std::vector<int> v3 { 5, 7, 9 };

        assert(( add(v1, 3) == v2 ));
        assert(( add(v1, v2) == v3 ));
    }

    // Mix-up the containers
    {
        std::list<int>   v1 { 1, 2, 3 };
        std::list<int>   v2 { 4, 5, 6 };
        std::list<int>   v3 { 5, 7, 9 };
        std::set<int>    v4 { 4, 5, 6 };
        std::vector<int> v5 { 3, 3, 3 };

        assert(( add(v1, 3) == v2 ));
        assert(( add(v1, v4) == v3 ));
        assert(( add(v1, v5) == v2 ));
    }

    // test strings (which overlap with case #1 and case #2)
    {
        std::string str1 { "abc" };
        std::string str2 { "def" };

        // Should be case #1
        assert(( add(str1, str2) == "abcdef" ));
    }

    {
        std::vector<std::string> v1 { "a", "b", "c" };
        std::vector<std::string> v2 { "a1", "b2", "c3" };
        std::string s1 { "123" };

        // should land in case #2
        assert(( add(v1, s1) == v2 ));
    }
}