implement generics in go using interfaces? - go

Question

I am trying to write a stack in Go which works for int and rune array type. But this does not seem to work. I thought that was supposed to work as I have an Interface type to hold any type. The operation of the stack is common for all types. I don't want to use the stack interface that comes with go
package main
import "math"
type expressionStack interface {
pop() interface
getSize() int
push(item interface)
peek() interface
}
type intStack []int
type runeStack []rune
func createStack(st interface) {
return &expressionStack{}
}
func (stack *expressionStack) getSize() int {
return len(stack)
}
func (stack *expressionStack) pop() int {
length := len(stack)
if length == 0 {
panic("Stack is underflown")
}
item := stack[length-1]
stack = stack[:length-1]
return item
}
func (stack *expressionStack) push(item interface) {
stack = append(stack, item)
}
func (stack *expressionStack) peek() int {
leng := len(stack)
if leng == 0 {
return -math.MaxInt32
}
item := stack[leng-1]
return item
}

Answer 1

a solution to those problem is to use code gen.
It requires to arrange a bit the api because generator are pretty dumb, but it does the job.
I start by declaring a package under GOPATH (old school) at test/d/gen
I create a new file template.go, and arranged a bit the code
package gen
type T int
type expressionStack []T
func (stack *expressionStack) getSize() int {
return len(*stack)
}
func (stack *expressionStack) pop() T {
length := len(*stack)
if length == 0 {
panic("Stack is underflown")
}
item := (*stack)[length-1]
*stack = (*stack)[:length-1]
return item
}
func (stack *expressionStack) push(item T) {
*stack = append(*stack, item)
}
func (stack *expressionStack) peek() (zero T, ok bool) {
leng := len(*stack)
if leng == 0 {
return
}
item := (*stack)[leng-1]
return item, true
}
I have tried to use https://github.com/mmatczuk/go_generics witth something like go_generics -t=T=int32 -t=expressionStack=IntStack -i=./template.go -o out.go -p gen, but it failed.
tried another one https://github.com/clementauger/jenjen with jenjen -template=test/d/gen "expressionStack:T => int32, T => -, expressionStack=>Int32Stack" -
I got a neat output
package gen
type Int32Stack []int32
func (stack *Int32Stack) getSize() int {
return len(*stack)
}
func (stack *Int32Stack) pop() int32 {
length := len(*stack)
if length == 0 {
panic("Stack is underflown")
}
item := (*stack)[length-1]
*stack = (*stack)[:length-1]
return item
}
func (stack *Int32Stack) push(item int32) {
*stack = append(*stack, item)
}
func (stack *Int32Stack) peek() (zero int32, ok bool) {
leng := len(*stack)
if leng == 0 {
return
}
item := (*stack)[leng-1]
return item, true
}
the hard stuff was to figure out that "expressionStack:T => int32, T => -, expressionStack=>Int32Stack", its a three statements instructions,
expressionStack: T=>int32 within expressionStack replace T by int32
T => -, within the package, remove T
expressionStack=>Int32Stack, within the package, rename expressionStack to Int32Stack
Though, i had some problem saving the output to the desired file with that last package. not perfect.
there is also a bunch of others package to do that,
https://github.com/cheekybits/genny
https://pkg.go.dev/cmd/gofmt with -r option

Answer 2

I think i found a solution
package main
import (
"math"
"reflect"
)
type expressionStack []interface{}
func (stack *expressionStack) getSize() int {
return len(*stack)
}
func (stack *expressionStack) pop() interface{} {
length := len(*stack)
if length == 0 {
panic("Stack is underflown")
}
item := (*stack)[length-1]
*stack = (*stack)[:length-1]
return item
}
func (stack *expressionStack) push(item interface{}) {
*stack = append(*stack, item)
}
func (stack *expressionStack) peek() interface{} {
leng := len(*stack)
if reflect.TypeOf(stack).Kind() == reflect.Int32 {
if leng == 0 {
return -math.MaxInt32
}
} else {
if leng == 0 {
return 'E'
}
}
item := (*stack)[leng-1]
return item
}