Go Collection Aggregate Operations

package main

import (
  "fmt"
  "slices"
)

func main() {
  numbers := []int{6, 42, 10, 4}

  // Go has no Sum(): add the elements up in a loop.
  sum := 0
  for _, n := range numbers {
    sum += n
  }

  fmt.Println("Count:", len(numbers))
  fmt.Println("Max:", slices.Max(numbers))
  fmt.Println("Min:", slices.Min(numbers))
  fmt.Println("Average:", float64(sum)/float64(len(numbers)))
  fmt.Println("Sum:", sum)
}

package main

import (
  "cmp"
  "fmt"
  "slices"
)

func main() {
  numbers := []int{5, 42, 10, 4}
  strings := []string{"one", "two", "three", "four"}

  // The element whose remainder after dividing by 3 is the smallest.
  minRem := slices.MinFunc(numbers, func(a, b int) int {
    return cmp.Compare(a%3, b%3)
  })
  fmt.Println(minRem)

  // The longest string, compared by length.
  longest := slices.MaxFunc(strings, func(a, b string) int {
    return cmp.Compare(len(a), len(b))
  })
  fmt.Println(longest)
}

package main

import "fmt"

// Number is any type that can be added with +.
type Number interface {
  ~int | ~float64
}

// SumOf turns every element into a number with f and adds the results up.
func SumOf[T any, N Number](items []T, f func(T) N) N {
  var total N
  for _, v := range items {
    total += f(v)
  }
  return total
}

func main() {
  numbers := []int{5, 42, 10, 4}

  fmt.Println(SumOf(numbers, func(n int) int { return n * 2 }))
  fmt.Println(SumOf(numbers, func(n int) float64 { return float64(n) / 2 }))
}

package main

import "fmt"

// Reduce starts with the first element and combines the rest into it.
func Reduce[T any](items []T, f func(T, T) T) T {
  acc := items[0]
  for _, v := range items[1:] {
    acc = f(acc, v)
  }
  return acc
}

func main() {
  numbers := []int{5, 2, 10, 4}

  sum := Reduce(numbers, func(sum, element int) int { return sum + element })
  fmt.Println(sum)
}

package main

import "fmt"

// Fold starts with an initial value and combines every element into it.
func Fold[T, R any](items []T, initial R, f func(R, T) R) R {
  acc := initial
  for _, v := range items {
    acc = f(acc, v)
  }
  return acc
}

func main() {
  numbers := []int{5, 2, 10, 4}

  sumDoubled := Fold(numbers, 0, func(sum, element int) int { return sum + element*2 })
  fmt.Println(sumDoubled)
}

package main

import "fmt"

// Reduce uses the first element as the start, so f is never applied to it.
func Reduce[T any](items []T, f func(T, T) T) T {
  acc := items[0]
  for _, v := range items[1:] {
    acc = f(acc, v)
  }
  return acc
}

// Fold uses initial as the start, so f is applied to every element.
func Fold[T, R any](items []T, initial R, f func(R, T) R) R {
  acc := initial
  for _, v := range items {
    acc = f(acc, v)
  }
  return acc
}

func main() {
  numbers := []int{5, 2, 10, 4}

  // 5 is the starting value here, so it is not doubled: 5 + 4 + 20 + 8
  reduced := Reduce(numbers, func(sum, element int) int { return sum + element*2 })
  fmt.Println("Reduce:", reduced)

  // Every element is doubled: 10 + 4 + 20 + 8
  folded := Fold(numbers, 0, func(sum, element int) int { return sum + element*2 })
  fmt.Println("Fold:", folded)
}

package main

import "fmt"

// FoldRight is like Fold, but it walks the slice from the last element to the first.
func FoldRight[T, R any](items []T, initial R, f func(T, R) R) R {
  acc := initial
  for i := len(items) - 1; i >= 0; i-- {
    acc = f(items[i], acc)
  }
  return acc
}

func main() {
  numbers := []int{5, 2, 10, 4}

  sumDoubledRight := FoldRight(numbers, 0, func(element, sum int) int { return sum + element*2 })
  fmt.Println(sumDoubledRight)
}

package main

import "fmt"

func main() {
  numbers := []int{5, 2, 10, 4}

  // range gives the index too, so the condition can use it.
  sumEven := 0
  for idx, element := range numbers {
    if idx%2 == 0 {
      sumEven += element
    }
  }
  fmt.Println(sumEven)
}

package main

import "fmt"

func main() {
  numbers := []int{5, 2, 10, 4}

  // Walk from the last index down to 0 and add the elements at even indexes.
  sumEven := 0
  for idx := len(numbers) - 1; idx >= 0; idx-- {
    if idx%2 == 0 {
      sumEven += numbers[idx]
    }
  }
  fmt.Println(sumEven)
}

package main

import "fmt"

// ReduceOK returns ok = false instead of panicking on an empty slice.
func ReduceOK[T any](items []T, f func(T, T) T) (T, bool) {
  var zero T
  if len(items) == 0 {
    return zero, false
  }
  acc := items[0]
  for _, v := range items[1:] {
    acc = f(acc, v)
  }
  return acc, true
}

func main() {
  numbers := []int{5, 2, 10, 4}
  empty := []int{}

  sum, ok := ReduceOK(numbers, func(sum, element int) int { return sum + element })
  fmt.Println(sum, ok)

  sum, ok = ReduceOK(empty, func(sum, element int) int { return sum + element })
  fmt.Println(sum, ok)
}

package main

import "fmt"

func main() {
  numbers := []int{0, 1, 2, 3, 4, 5}

  // The first element is the start; every later step is saved in the result.
  sum := numbers[0]
  runningReduceSum := []int{sum}
  for _, item := range numbers[1:] {
    sum += item
    runningReduceSum = append(runningReduceSum, sum)
  }
  fmt.Println(runningReduceSum)
}

package main

import "fmt"

func main() {
  numbers := []int{0, 1, 2, 3, 4, 5}

  // The initial value 10 is the first element of the result.
  sum := 10
  runningFoldSum := []int{sum}
  for _, item := range numbers {
    sum += item
    runningFoldSum = append(runningFoldSum, sum)
  }
  fmt.Println(runningFoldSum)
}