Generico! Дженерики в go или стоит ли оно того

package main

type (
	iNode struct {
		val  interface{}
		next *iNode
	}
	InterfaceStack struct {
		top *iNode
		len int
	}
)

func NewInterfaceStack() *InterfaceStack {
	return &InterfaceStack{}
}

func (istack *InterfaceStack) Push(val interface{}) {
	var n iNode = iNode{val: val, next: istack.top}
	istack.len += 1
	istack.top = &n
}

func (istack *InterfaceStack) Pop() interface{} {
	if istack.len <= 0 {
		return nil
	}
	istack.len -= 1
	var n *iNode = istack.top
	istack.top = n.next
	return n.val
}

func (istack *InterfaceStack) Peak() interface{} {
	if istack.len <= 0 {
		return nil
	}
	return istack.top.val
}

func (istack *InterfaceStack) Len() int {
	return istack.len
}

package main

type (
	gNode[NT any] struct {
		val  NT
		next *gNode[NT]
	}
	GenericStack[ST any] struct {
		top *gNode[ST]
		len int
	}
)

func NewGenericStack[GS any]() *GenericStack[GS] {
	return &GenericStack[GS]{}
}

func (gstack *GenericStack[ST]) Push(val ST) {
	var n gNode[ST] = gNode[ST]{val: val, next: gstack.top}
	gstack.len += 1
	gstack.top = &n
}

func (gstack *GenericStack[ST]) Pop() (res ST, exists bool) {
	if gstack.len <= 0 {
		exists = false
		return
	}
	gstack.len -= 1

	var n *gNode[ST] = gstack.top
	gstack.top = n.next
	return n.val, true
}

func (gstack *GenericStack[ST]) Peak() (res ST, exists bool) {
	if gstack.len <= 0 {
		exists = false
		return
	}
	return gstack.top.val, true
}

func (gstack GenericStack[ST]) Len() int {
	return gstack.len
}

package main

import "fmt"

func main() {
	// Interface
	istack := NewInterfaceStack()
	istack.Push(12)
	istack.Push(32)
	ival := istack.Pop();
	if ival != nil{
		if val, ok := ival.(int); !ok {
			panic("wrong type in interface stack")
		} else {
			fmt.Printf("Got '%v' from interface stackn", val)
		}
    }
  
	// Generic
	gstack := NewGenericStack[int]()
	gstack.Push(54)
	gstack.Push(67)
	if val, exists := gstack.Pop(); exists {
		fmt.Printf("Got '%v' from generic stackn", val)
	}
}

package main

import "testing"

type iTestNode struct {
	val		int
}

func createINode(value int) iTestNode {
	return iTestNode{value}
}

func BenchmarkInterfaceSimpleType(b *testing.B) {
	st := NewInterfaceStack()
	val := 1
	for i := 0; i < b.N; i += 1 {
		st.Push(val)
		if _, ok := st.Pop().(int); !ok {
			panic("Wrong type of data in stack")
		}
	}
}

func BenchmarkInterfaceSimpleCustomType(b *testing.B) {
	st := NewInterfaceStack()
	node := createINode(12)
	for i := 0; i < b.N; i += 1 {
		st.Push(node)
		if _, ok := st.Pop().(iTestNode); !ok {
			panic("Wrong type of data in stack")
		}
	}
}

func BenchmarkInterfaceCustomTypePointer(b *testing.B) {
	st := NewInterfaceStack()
	node := createINode(12)
	for i := 0; i < b.N; i += 1 {
		st.Push(&node)
		if _, ok := st.Pop().(*iTestNode); !ok {
			panic("Wrong type of data in stack")
		}
	}
}

package main

import "testing"

type gTestNode struct {
UserId int64
UserName string
AccessLevel int
Telegram string
Phone string
Skype string
Slack string
Blog string
Instagram string
Facebook string
Twitter string
Avatar []byte
Status string
}

func createGNode() gTestNode {
return gTestNode{
UserId: 12,
UserName: "someuser",
AccessLevel: 99,
Telegram: @someuserr",
Phone: "123456789",
Skype: "someUser",
Slack: "someuser",
Blog: "",
Instagram: @instasomeuserr",
Facebook: "facebook.com/someuser",
Twitter: "twitter.com/someuser",
Avatar: make([]byte, 0),
Status: "ONLINE",
}
}

//go:noinline
func BenchmarkGenericSimpleType(b *testing.B) {
b.StopTimer()
st := NewGenericStackstring
val := "some string for tests"
b.StartTimer()
for i := 0; i < b.N; i += 1 {
st.Push(val)
st.Pop()
}
}

//go:noinline
func BenchmarkGenericCustomType(b *testing.B) {
b.StopTimer()
st := NewGenericStackgTestNode
node := createGNode()
b.StartTimer()
for i := 0; i < b.N; i += 1 {
st.Push(node)
st.Pop()
}
}

//go:noinline
func BenchmarkGenericCustomTypePointer(b *testing.B) {
b.StopTimer()
st := NewGenericStack*gTestNode
node := createGNode()
b.StartTimer()
for i := 0; i < b.N; i += 1 {
st.Push(&node)
st.Pop()
}
}

package main

import "testing"

type gTestNode struct {
	val      int64
}

func createGNode(value int) gTestNode {
	return gTestNode{value}
}

func BenchmarkGenericSimpleType(b *testing.B) {
	st := NewGenericStack[int]()
	val := 1
	for i := 0; i < b.N; i += 1 {
		st.Push(val)
		st.Pop()
	}
}

func BenchmarkGenericCustomType(b *testing.B) {
	st := NewGenericStack[gTestNode]()
	node := createGNode()
	for i := 0; i < b.N; i += 1 {
		st.Push(node)
		st.Pop()
	}
}

func BenchmarkGenericCustomTypePointer(b *testing.B) {
	st := NewGenericStack[*gTestNode]()
	node := createGNode()
	for i := 0; i < b.N; i += 1 {
		st.Push(&node)
		st.Pop()
	}
}

CPU: 8-core AMD Ryzen 7 4700U with Radeon Graphics (-MCP-)
speed/min/max: 1482/1400/2000 MHz Kernel: 5.15.85-1-MANJARO x86_64
Mem: 5500.4/31499.2 MiB (17.5%)
inxi: 3.3.24

goos: linux
goarch: amd64
pkg: github.com/HoskeOwl/goSimpleStack
cpu: AMD Ryzen 7 4700U with Radeon Graphics         
BenchmarkGenericSimpleType-8                    313764921               77.92 ns/op
BenchmarkGenericCustomType-8                    317463438               71.97 ns/op
BenchmarkGenericCustomTypePointer-8             218245879              111.0 ns/op
BenchmarkInterfaceSimpleType-8                  213324286              113.0 ns/op
BenchmarkInterfaceSimpleCustomType-8            222740674              112.8 ns/op
BenchmarkInterfaceCustomTypePointer-8           218896858              111.9 ns/op

goos: linux
goarch: amd64
pkg: github.com/HoskeOwl/goSimpleStack
cpu: AMD Ryzen 7 4700U with Radeon Graphics         
BenchmarkGenericSimpleType-8                    353000452               71.54 ns/op
BenchmarkGenericCustomType-8                    338031572               73.45 ns/op
BenchmarkGenericCustomTypePointer-8             323049594               73.77 ns/op
BenchmarkInterfaceSimpleType-8                  297199362               78.44 ns/op
BenchmarkInterfaceSimpleCustomType-8            298851950               81.57 ns/op
BenchmarkInterfaceCustomTypePointer-8           291001880               83.04 ns/op
PASS
ok      github.com/HoskeOwl/goSimpleStack       191.971s

goos: linux
goarch: amd64
pkg: github.com/HoskeOwl/goSimpleStack
cpu: AMD Ryzen 7 4700U with Radeon Graphics         
BenchmarkGenericSimpleType-8                    323416230               72.84 ns/op
BenchmarkGenericCustomType-8                    325032516               71.51 ns/op
BenchmarkGenericCustomTypePointer-8             320308387               75.60 ns/op
BenchmarkInterfaceSimpleType-8                  290263794               81.65 ns/op
BenchmarkInterfaceSimpleCustomType-8            296999368               81.06 ns/op
BenchmarkInterfaceCustomTypePointer-8           291887139               82.64 ns/op
PASS
ok      github.com/HoskeOwl/goSimpleStack       190.310s

goos: linux
goarch: amd64
pkg: github.com/HoskeOwl/goSimpleStack
cpu: AMD Ryzen 7 4700U with Radeon Graphics         
BenchmarkGenericSimpleType-8                    261289566               90.09 ns/op
BenchmarkGenericCustomType-8                    99811050               228.6 ns/op
BenchmarkGenericCustomTypePointer-8             291460882               80.94 ns/op
BenchmarkInterfaceSimpleType-8                  163295492              149.5 ns/op
BenchmarkInterfaceSimpleCustomType-8            84240980               285.6 ns/op
BenchmarkInterfaceCustomTypePointer-8           311288221               78.62 ns/op
PASS
ok      github.com/HoskeOwl/goSimpleStack       183.679s

Ожидаемо - большие структуры много времени забирают на копирование, в этом случае - дженерики вас не спасут. А положение исправит передача структур через ссылки, причём в обоих случаях.