generics.go

package main

import (
	"fmt"
)

type Number interface {
	~int | ~int8 | ~int16 | ~int32 | ~int64
}

func PrintSlice[T any](n []T) {
	for i := range n {
		fmt.Print(n[i])
		fmt.Print(" ")
	}
	fmt.Println()
}

func merge[T Number](nums []T, begin, mid, end int) {
	leftArr := make([]T, 0)
	rightArr := make([]T, 0)

	for i := begin; i <= mid; i++ {
		leftArr = append(leftArr, nums[i])
	}

	for i := mid + 1; i <= end; i++ {
		rightArr = append(rightArr, nums[i])
	}

	mergedIndex := begin
	leftArrIndex := 0
	rightArrIndex := 0

	for leftArrIndex < len(leftArr) && rightArrIndex < len(rightArr) {
		if leftArr[leftArrIndex] < rightArr[rightArrIndex] {
			nums[mergedIndex] = leftArr[leftArrIndex]
			leftArrIndex++
		} else {
			nums[mergedIndex] = rightArr[rightArrIndex]
			rightArrIndex++
		}
		mergedIndex++
	}

	for leftArrIndex < len(leftArr) {
		nums[mergedIndex] = leftArr[leftArrIndex]
		leftArrIndex++
		mergedIndex++
	}

	for rightArrIndex < len(rightArr) {
		nums[mergedIndex] = rightArr[rightArrIndex]
		rightArrIndex++
		mergedIndex++
	}
}

func MergeSort[T Number](nums []T, begin, end int) {
	if begin >= end {
		return
	}
	mid := (begin + end) / 2
	MergeSort(nums, begin, mid)
	MergeSort(nums, mid+1, end)
	merge(nums, begin, mid, end)
}

func main() {
	fmt.Println("Hello Go 1.18")
	fmt.Println("Thanks for Generics")

	intNums := []int{2, 3, 1, 5, 4}
	int8Nums := []int8{2, 3, 1, 5, 4}
	int16Nums := []int16{2, 3, 1, 5, 4}
	int32Nums := []int32{2, 3, 1, 5, 4}
	int64Nums := []int64{2, 3, 1, 5, 4}

	MergeSort(intNums, 0, len(intNums)-1)
	MergeSort(int8Nums, 0, len(int8Nums)-1)
	MergeSort(int16Nums, 0, len(int16Nums)-1)
	MergeSort(int32Nums, 0, len(int32Nums)-1)
	MergeSort(int64Nums, 0, len(int64Nums)-1)

	PrintSlice(intNums)
	PrintSlice(int8Nums)
	PrintSlice(int16Nums)
	PrintSlice(int32Nums)
	PrintSlice(int64Nums)
}

// Console output:
// Hello Go 1.18
// Thanks for Generics
// 1 2 3 4 5
// 1 2 3 4 5
// 1 2 3 4 5
// 1 2 3 4 5
// 1 2 3 4 5