scratch @ efe3f18614c0e2e1994d738b5e9bd127df509d6d

···
        31
        31
         	is(t, ok, true)

      
        32
        32
         	is(t, v, 11)

      
        33
        33
         

      
        
        34
        +	_, ok = q.Pop()

      
        
        35
        +	is(t, ok, false)

      
        
        36
        +

      
        34
        37
         	// everything works after removing all elements

      
        35
        38
         	q.Push(69420)

      
        36
        39
         	is(t, q.Peek(), 69420)

      

···
        
        1
        +package algos

      
        
        2
        +

      
        
        3
        +type SNode[T any] struct {

      
        
        4
        +	v    T

      
        
        5
        +	prev *SNode[T]

      
        
        6
        +}

      
        
        7
        +

      
        
        8
        +type Stack[T any] struct {

      
        
        9
        +	Len  int

      
        
        10
        +	head *SNode[T]

      
        
        11
        +}

      
        
        12
        +

      
        
        13
        +func (s *Stack[T]) Push(item T) {

      
        
        14
        +	node := &SNode[T]{v: item, prev: s.head}

      
        
        15
        +	s.head = node

      
        
        16
        +	s.Len++

      
        
        17
        +}

      
        
        18
        +

      
        
        19
        +func (s *Stack[T]) Peek() T {

      
        
        20
        +	return s.head.v

      
        
        21
        +}

      
        
        22
        +

      
        
        23
        +func (s *Stack[T]) Pop() (val T, ok bool) {

      
        
        24
        +	if s.Len == 0 {

      
        
        25
        +		var t T

      
        
        26
        +		return t, false

      
        
        27
        +	}

      
        
        28
        +	res := s.head.v

      
        
        29
        +	s.head = s.head.prev

      
        
        30
        +	s.Len--

      
        
        31
        +	return res, true

      
        
        32
        +}

      

···
        
        1
        +package algos

      
        
        2
        +

      
        
        3
        +import "testing"

      
        
        4
        +

      
        
        5
        +func TestStack(t *testing.T) {

      
        
        6
        +	s := Stack[int]{}

      
        
        7
        +

      
        
        8
        +	s.Push(5)

      
        
        9
        +	s.Push(7)

      
        
        10
        +	s.Push(9)

      
        
        11
        +

      
        
        12
        +	v, ok := s.Pop()

      
        
        13
        +	is(t, ok, true)

      
        
        14
        +	is(t, v, 9)

      
        
        15
        +

      
        
        16
        +	is(t, s.Len, 2)

      
        
        17
        +

      
        
        18
        +	s.Push(11)

      
        
        19
        +

      
        
        20
        +	v, ok = s.Pop()

      
        
        21
        +	is(t, ok, true)

      
        
        22
        +	is(t, v, 11)

      
        
        23
        +

      
        
        24
        +	v, ok = s.Pop()

      
        
        25
        +	is(t, ok, true)

      
        
        26
        +	is(t, v, 7)

      
        
        27
        +

      
        
        28
        +	is(t, s.Peek(), 5)

      
        
        29
        +

      
        
        30
        +	v, ok = s.Pop()

      
        
        31
        +	is(t, ok, true)

      
        
        32
        +	is(t, v, 5)

      
        
        33
        +

      
        
        34
        +	_, ok = s.Pop()

      
        
        35
        +	is(t, ok, false)

      
        
        36
        +

      
        
        37
        +	s.Push(69420)

      
        
        38
        +	is(t, s.Peek(), 69420)

      
        
        39
        +

      
        
        40
        +	v, ok = s.Pop()

      
        
        41
        +	is(t, ok, true)

      
        
        42
        +	is(t, v, 69420)

      
        
        43
        +}