A simple LIFO stack backed by a linked list implemented with golang.

stack.go

package main

import (
	"fmt"
)

type Stack struct {
	top *Element
	size int
}

type Element struct {
	value interface{} // All types satisfy the empty interface, so we can store anything here.
	next *Element
}

// Return the stack's length
func (s *Stack) Len() int {
	return s.size
}

// Push a new element onto the stack
func (s *Stack) Push(value interface{}) {
	s.top = &Element{value, s.top}
	s.size++
}

// Remove the top element from the stack and return it's value
// If the stack is empty, return nil
func (s *Stack) Pop() (value interface{}) {
	if s.size > 0 {
		value, s.top = s.top.value, s.top.next
		s.size--
		return
	}
	return nil
}

func main() {
	stack := new(Stack)
	
	stack.Push("Things")
	stack.Push("and")
	stack.Push("Stuff")
	
	for stack.Len() > 0 {
		// We have to do a type assertion because we get back a variable of type
		// interface{} while the underlying type is a string.
		fmt.Printf("%s ", stack.Pop().(string))
	}
	fmt.Println()
}

Thanks for the implementation example! I probably would have used a slice or something silly.

Used this as the basis for a typed stack here:
https://github.com/tooolbox/go-xib-strings/blob/master/stack.go

Thanks again.

According to ur design, I implement another version of stack via Slice. Which will be used in one of my project.

This is the stack link : https://github.com/tonyshaw/Stack

Thanks.

Let me add my thanks, too!

I added @alinz Peep and I added a PopLast and maximum capacity.

https://gist.github.com/markturansky/3f2273ae39f970ff56ff22a047cc6345