Ad hoc polymorphism in C#

AdHoc.cs

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            var xs = new[] {"one", " ", "two", " ", "three"};
            var ys = new[] {1, 2, 3};

            var rx = AddAll<MString, string>(xs);
            var ry = AddAll<MInt, int>(ys);

            Console.WriteLine(rx);
            Console.WriteLine(ry);
        }

        static A AddAll<MA, A>(A[] xs) where MA : struct, Monoid<A>
        {
            var result = default(MA).Zero;
            foreach (var x in xs)
            {
                result = default(MA).Add(result, x);
            }

            return result;
        }
    }

    public interface Semigroup<A>
    {
        A Add(A x, A y);
    }

    public interface Monoid<A> : Semigroup<A>
    {
        A Zero { get; }
    }

    public struct MInt : Monoid<int>
    {
        public int Add(int x, int y) =>
            x + y;

        public int Zero =>
            0;
    }

    public struct MString : Monoid<string>
    {
        public string Add(string x, string y) =>
            x + y;

        public string Zero =>
            "";
    }

}