JohnMGant

function Add(values) {
  let sum = 0
  for (var value of values) {
    sum += value
  }
  return sum
}

JohnMGant

function Add(values) {
  let sum = 0
  values.forEach(val => sum += val)
  return sum
}

JohnMGant

function Add(values) {
  return values.reduce((sum, val) => sum += val)
}

JohnMGant

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

JohnMGant

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

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 ArrayHeadTailAdder : IIntegerAdder
{
  
    //This will fail with large arrays
    public int Add(int[] values)
    {            
        var (head, tail) = GetHeadAndTail(values);
        return AddImplentation(head, tail);
    }

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 unsafe class PointerHeadTailAdder : IIntegerAdder
{

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

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();