JohnMGant

internal class ConcurrentBatchAdder : IIntegerAdder
{

    private const int degreeOfParallelism = 4;

    public int Add(int[] values)
    {
        var countPerSegment = values.Length / degreeOfParallelism + 1;
        int[,] segments = SplitIntoSegments(values, countPerSegment);
        var sums = new int[degreeOfParallelism];

JohnMGant

internal class ParallelAdder : IIntegerAdder
{
    public int Add(int[] values)
    {
        var queue = new ConcurrentQueue<int>(values);
        int overallSum = 0;
        Action addFromQueue = () =>
        {
            int localSum = 0;
            while (queue.TryDequeue(out int localValue))

JohnMGant

internal class QueuingAdder : IIntegerAdder
{
    public int Add(int[] values)
    {
        var queue = new Queue<int>(values);
        var sum = 0;
        while (queue.TryDequeue(out int value))
        {
            sum += value;
        }

JohnMGant

internal static class ExtensionMethods
{
    public static bool TryDequeue<T>(this Queue<T> queue, out T result)
    {
        result = default;
        if (queue == null || !queue.Any())
        {
            return false;
        }
        result = queue.Dequeue();

JohnMGant

internal unsafe class PointerHeadTailAdder : IIntegerAdder
{

    public int Add(int[] values)
    {
        fixed (int* head = values)
        {
            return AddImplementation(head, values.Length);
        }
    }

JohnMGant

internal class LinqHeadTailAdder : IIntegerAdder
{

    private const int maxSupportedLength = 10000;

    public int Add(int[] values)
    {
        if (values.Length > maxSupportedLength)
        {
            throw new NotSupportedException($"Max supported length is {maxSupportedLength}");

JohnMGant

internal class ArrayHeadTailAdder : IIntegerAdder
{
  
    //This will fail with large arrays
    public int Add(int[] values)
    {            
        var (head, tail) = GetHeadAndTail(values);
        return AddImplentation(head, tail);
    }

JohnMGant

let addInts ints =
   let rec loop list acc =
       match list with
       | head :: tail -> loop tail (acc + head)
       | [] -> acc
   loop ints 0

JohnMGant

internal class LinqSumAdder : IIntegerAdder
{
  public int Add(int[] values) => values.Sum();
}

JohnMGant

internal class LinqAggregateAdder : IIntegerAdder
{
  public int Add(int[] values) => values.Aggregate((sum, val) => sum += val);        
}