func ContainsBefore(numbers []int, n int) bool {
 for _, number := range numbers {
  if number == n {
   return true
  }
 }
 return false
}

import "slices"
...
slices.Contains(numbers, 3)

func EqualBefore(a, b []int) bool {
 if len(a) != len(b) {
  return false
 }
 for i, number := range a {
  if number != b[i] {
   return false
  }
 }
 return true
}

import "slices"
...
slices.Equal(a, b)

func CompactBefore(numbers []int) []int {
 var result []int
 for _, number := range numbers {
  if len(result) == 0 || result[len(result)-1] != number {
   result = append(result, number)
  }
 }
 return result
}

import "slices"
...
compacted := slices.Compact(numbers)
// for numbers []int{1, 2, 3, 3, 4, 5, 5}
// compacted is []int{1, 2, 3, 4, 5}

func ReverseBefore(numbers []int) {
 for i := 0; i < len(numbers)/2; i++ {
  j := len(numbers) - i - 1
  numbers[i], numbers[j] = numbers[j], numbers[i]
 }
}

import "slices"
...
slices.Reverse(numbers)

func BeforeEqual(m1, m2 map[string]string) bool {
 if len(m1) != len(m2) {
  return false
 }
 for k, v := range m1 {
  if v != m2[k] {
   return false
  }
 }
 return true
}

import "maps"
...
maps.Equal(m1, m2)

func DeleteBefore(m map[string]string) {
 for k, v := range m {
  if v == "before" {
   delete(m, k)
  }
 }
}

import "maps"
...
maps.DeleteFunc(m, func(k, v string) bool {
  return v == "after"
 })

numbers := []int{1, 2, 3, 4, 5}
clear(numbers)
// After clear
// Capacity is 5
// Lenght is 5
// numbers is [0 0 0 0 0]

m := map[string]string{
  "first":  "before",
  "second": "after",
 }
clear(m)
// After clear
// Lenght is 0
// map is empty