Агрегатные операции над коллекциями в Go

package main

import (
  "fmt"
  "slices"
)

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

  // В Go нет функции Sum(): складываем элементы в цикле.
  sum := 0
  for _, n := range numbers {
    sum += n
  }

  fmt.Println("Количество:", len(numbers))
  fmt.Println("Максимум:", slices.Max(numbers))
  fmt.Println("Минимум:", slices.Min(numbers))
  fmt.Println("Среднее:", float64(sum)/float64(len(numbers)))
  fmt.Println("Сумма:", sum)
}

package main

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

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

  // Элемент, у которого остаток от деления на 3 самый маленький.
  minRem := slices.MinFunc(numbers, func(a, b int) int {
    return cmp.Compare(a%3, b%3)
  })
  fmt.Println(minRem)

  // Самая длинная строка, сравнение по длине.
  longest := slices.MaxFunc(strings, func(a, b string) int {
    return cmp.Compare(len(a), len(b))
  })
  fmt.Println(longest)
}

package main

import "fmt"

// Number — это любой тип, который можно складывать с помощью +.
type Number interface {
  ~int | ~float64
}

// SumOf превращает каждый элемент в число с помощью f и складывает результаты.
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 начинает с первого элемента и соединяет с ним остальные.
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 начинает с начального значения и соединяет с ним каждый элемент.
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 берёт за начало первый элемент, поэтому f к нему никогда не применяется.
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 берёт за начало initial, поэтому f применяется к каждому элементу.
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 — начальное значение, поэтому оно не удваивается: 5 + 4 + 20 + 8
  reduced := Reduce(numbers, func(sum, element int) int { return sum + element*2 })
  fmt.Println("Reduce:", reduced)

  // Каждый элемент удваивается: 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 работает как Fold, но идёт по slice от последнего элемента к первому.
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 даёт ещё и индекс, поэтому условие может его использовать.
  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}

  // Идём от последнего индекса вниз до 0 и складываем элементы с чётными индексами.
  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 возвращает ok = false вместо паники на пустом 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}

  // Первый элемент — начало; каждый следующий шаг сохраняется в результате.
  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}

  // Начальное значение 10 — это первый элемент результата.
  sum := 10
  runningFoldSum := []int{sum}
  for _, item := range numbers {
    sum += item
    runningFoldSum = append(runningFoldSum, sum)
  }
  fmt.Println(runningFoldSum)
}