Looking for reasonable stack implementation in golang?

So far my naive approach is

type stack []int

func (s *stack) Push(v int) {
	*s = append(*s, v)
}

func (s *stack) Pop() int {
	res:=(*s)[len(*s)-1]
	*s=(*s)[:len(*s)-1]
	return res
}

it works - playground, but looks ugly and has too much dereferencing. Can I do better?

It's a matter of style and personal taste, your code is fine (apart from not being thread safe and panicking if you pop from an empty stack). To simplify it a bit you can work with value methods and return the stack itself, it's slightly more elegant to some tastes. i.e.

type stack []int

func (s stack) Push(v int) stack {
    return append(s, v)
}

func (s stack) Pop() (stack, int) {
    // FIXME: What do we do if the stack is empty, though?

    l := len(s)
    return  s[:l-1], s[l-1]
}


func main(){
    s := make(stack,0)
    s = s.Push(1)
    s = s.Push(2)
    s = s.Push(3)
    
    s, p := s.Pop()
    fmt.Println(p)
 
}

Another approach is to wrap it in a struct, so you can also easily add a mutex to avoid race conditions, etc. something like:

type stack struct {
     lock sync.Mutex // you don't have to do this if you don't want thread safety
     s []int
}

func NewStack() *stack {
    return &stack {sync.Mutex{}, make([]int,0), }
}

func (s *stack) Push(v int) {
    s.lock.Lock()
    defer s.lock.Unlock()
    
    s.s = append(s.s, v)
}

func (s *stack) Pop() (int, error) {
    s.lock.Lock()
    defer s.lock.Unlock()
    
    
    l := len(s.s)
    if l == 0 {
        return 0, errors.New("Empty Stack")
    }
    
    res := s.s[l-1]
    s.s = s.s[:l-1]
    return res, nil
}


func main(){
    s := NewStack()
    s.Push(1)
    s.Push(2)
    s.Push(3)
	fmt.Println(s.Pop())
    fmt.Println(s.Pop())
    fmt.Println(s.Pop())
}

Here is a LIFO implementation using linked data structure

package stack

import "sync"

type element struct {
	data interface{}
	next *element
}

type stack struct {
	lock *sync.Mutex
	head *element
	Size int
}

func (stk *stack) Push(data interface{}) {
	stk.lock.Lock()

	element := new(element)
	element.data = data
	temp := stk.head
	element.next = temp
	stk.head = element
	stk.Size++

	stk.lock.Unlock()
}

func (stk *stack) Pop() interface{} {
	if stk.head == nil {
		return nil
	}
   	stk.lock.Lock()
	r := stk.head.data
	stk.head = stk.head.next
	stk.Size--

	stk.lock.Unlock()

	return r
}

func New() *stack {
	stk := new(stack)
	stk.lock = &sync.Mutex{}

	return stk
}

I believe it would be nice if we could take advantage of Go's standard libs instead of creating self-defined data structure like @guy_fawkes did. Although he did a great job, it's not a standard way to use singly linked list.

To get list's tail in O(1) time complexity, I would use doubly linked list. I trade space for time.

I also take @Not_a_Golfer's advice to add a lock to the stack.

import (
	"container/list"
	"sync"
)

type Stack struct {
	dll   *list.List
	mutex sync.Mutex
}

func NewStack() *Stack {
	return &Stack{dll: list.New()}
}

func (s *Stack) Push(x interface{}) {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	s.dll.PushBack(x)
}

func (s *Stack) Pop() interface{} {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	if s.dll.Len() == 0 {
		return nil
	}
	tail := s.dll.Back()
	val := tail.Value
	s.dll.Remove(tail)
	return val
}

Click this playground to preview the result.

With the introduction of generics you can now create some pretty elegant implementations, here's one using a more functional style:

package main

import (
    "fmt"
)

type stack[T any] struct {
    Push func(T)
    Pop func() T
    Length func() int
}

func Stack[T any]() stack[T] {
    slice := make([]T, 0)
    return stack[T]{
        Push: func(i T) {
            slice = append(slice, i)
        },
        Pop: func() T {
            res := slice[len(slice)-1]
            slice = slice[:len(slice)-1]
            return res
        },
        Length: func() int {
            return len(slice)
        },
    }
}


func main() {
    stack := Stack[string]()
    stack.Push("this")
    fmt.Println(stack.Length())
    fmt.Println(stack.Pop())
}

Use https://github.com/emirpasic/gods

package main

import lls "github.com/emirpasic/gods/stacks/linkedliststack"

func main() {
	stack := lls.New()  // empty
	stack.Push(1)       // 1
	stack.Push(2)       // 1, 2
	stack.Values()      // 2, 1 (LIFO order)
	_, _ = stack.Peek() // 2,true
	_, _ = stack.Pop()  // 2, true
	_, _ = stack.Pop()  // 1, true
	_, _ = stack.Pop()  // nil, false (nothing to pop)
	stack.Push(1)       // 1
	stack.Clear()       // empty
	stack.Empty()       // true
	stack.Size()        // 0
}

> Can I do better?

With generics released, we can generalize your implementation like this:

package main

import (
	"fmt"
	"log"
)

// Generic stack
// One should implement better constraints
type stack[V any] []V

func (s *stack[V]) Push(v V) int {
	*s = append(*s, v)
	return len(*s)
}
func (s *stack[V]) Last() V {
	l := len(*s)

    // Upto the developer to handle an empty stack
	if l == 0 {
		log.Fatal("Empty Stack")
	}

	last := (*s)[l-1]
	return last
}

func (s *stack[V]) Pop() V {
	removed := (*s).Last()
	*s = (*s)[:len(*s)-1]

	return removed
}

// Pointer not needed because read-only operation
func (s stack[V]) Values() {
	for i := len(s) - 1; i >= 0; i-- {
		fmt.Printf("%v ", s[i])
	}
}

Playground

My Stack implimentation:
The advantages are:

1. Use "slice" no need to retune memory is automatically tuned!
2. It is safe for "multithreading"
3. Not easy to corrupt information
4. Generics are used so it is flexible in use with different types of data.

The disadvantages are:

1. You can't remove, use an random item

stack := utility.NewStack[string]()
stack.Push("1")
stack2 := utility.NewStack[[]int]()
stack2.Push([]int{1, 2, 3, 4, 5})
element, _ := stack2.Peek()

// Using Generics to define Type in Stake to Use Structs, too.
type Stack[T any] struct {
	lock sync.Mutex // Mutex for Thread safety
	S    []T // Slice
}

func NewStack[T any]() *Stack[T] {
	return &Stack[T]{lock: sync.Mutex{}, S: []T{}}
}

func (stack *Stack[T]) Push(element T) {
	stack.lock.Lock()
	defer stack.lock.Unlock()
	stack.S = append(stack.S, element)
}

func (stack *Stack[T]) Pop() (T, error) {
	stack.lock.Lock()
	defer stack.lock.Unlock()
	l := len(stack.S)
	if l == 0 {
		var empty T
		return empty, errors.New("empty Stack")
	}
	element := stack.S[l-1]
	stack.S = stack.S[:l-1]
	return element, nil
}

func (stack *Stack[T]) Peek() (T, error) {
	stack.lock.Lock()
	defer stack.lock.Unlock()
	l := len(stack.S)
	if l == 0 {
		var empty T
		return empty, errors.New("empty Stack")
	}
	return stack.S[l-1], nil
}

One more addition to concurrency safe stack implementation in Golang.

Supporting operations like:

1. Push(value interface{})
2. Peek() interface{}
3. Pop()
4. Size() int
5. Reverse()
6. Display()

package main
import (
"fmt"
"sync"
)
type StackMethods interface {
Push(value interface{})
Peek() interface{}
Pop()
Size() int
Reverse()
Display()
}
type Stack struct {
node *Node
size int
lock sync.Mutex
}
type Node struct {
value interface{}
next  *Node
}
func (s *Stack) Size() int {
return s.size
}
func (s *Stack) Push(value interface{}) {
s.lock.Lock()
defer s.lock.Unlock()
s.node = &Node{
value: value,
next:  s.node,
}
s.size++
}
func (s *Stack) Peek() interface{} {
if s.size > 0 {
fmt.Println("Element: ", s.node.value)
return s.node.value
} else {
fmt.Println("No elements in stack to display.")
}
return nil
}
func (s *Stack) Pop() {
s.lock.Lock()
defer s.lock.Unlock()
if s.size > 0 {
fmt.Printf("Removing element %v from stack.\n", s.node.value)
s.node = s.node.next
s.size--
} else {
fmt.Println("No elements in stack to remove.")
}
}
func (s *Stack) Reverse() {
s.lock.Lock()
defer s.lock.Unlock()
if s.node != nil {
var next, prev *Node
curr := s.node
for curr != nil {
next = curr.next
curr.next = prev
prev = curr
curr = next
}
s.node = prev
return
}
}
func (s *Stack) Display() {
if s.node != nil {
ptr := s.node
fmt.Println("Displaying elements")
for ptr != nil {
fmt.Print(ptr.value, "\n")
fmt.Println("____")
ptr = ptr.next
}
return
}
fmt.Println("Stack is empty.")
}
func main() {
//Creating interface object.
var stackObject StackMethods
//Assigning Stack struct object to interface object.
stackObject = new(Stack)
stackObject.Push("A")
fmt.Println("Size:", stackObject.Size())
stackObject.Peek()
stackObject.Peek()
fmt.Println("Size:", stackObject.Size())
stackObject.Push("B")
stackObject.Push("C")
fmt.Println("Size:", stackObject.Size())
stackObject.Peek()
fmt.Println("Size:", stackObject.Size())
fmt.Println("Before Reversing:")
stackObject.Display()
fmt.Println("After Reversing:")
stackObject.Reverse()
stackObject.Display()
}