Coding a linked list in Golang with generics

package main

import (
	"fmt"
)

// Node represents a node in the linked list
type Node[T any] struct {
	data T
	next *Node[T]
}

// LinkedList represents a linked list
type LinkedList[T any] struct {
	head   *Node[T]
	length int
}

// Append method adds a new node with the given data at the end of the list.
// Appends takes a parameter 'data' of generic type 'T' . 
// 'll' is the receiver of this method representing the instance of 'LinkedList' on which 'Append' is called.
func (ll *LinkedList[T]) Append(data T) {
	// A new node is created and a pointer is assigned to 'newNode'.
	// This new node will be appended to the end of the list.
	// The node is of type 'Node[T]' with 'data' set to the value passed to the 'Append' method.
	newNode := &Node[T]{data: data}
	// The 'if' statement checks if the list is empty (i.e, 'head' is nil).
	// If the list is empty, the new node will become the first(head) of the list.
	if ll.head == nil {
		// In case of empty list (i.e,'head' is 'nil'), the head of the list set tot the new node.
		ll.head = newNode
		// The 'else' block is executed if the list already has one node (i.e, 'head' is not 'nil').
	} else {
		// A local variable 'current' is assigned to the value of 'head' marking the start of the list.
		// This variable will be used to traverse the entire list.
		current := ll.head
		// A loop iterates through the list and continues until 'current.next' is 'nil', indicating that 'current' is the last node in the list.
		for current.next != nil {
			// Within this loop, 'current' is updates to point to the next node in the list, moving the traversal process forward.
			current = current.next
		}
		// Once the end of list is reached(the last node where 'current.next' is 'nil'), this line 
		// sets 'current.next' to the new node, effectively appending the new node to the end of the list.
		current.next = newNode
	}
	// Incrementing the 'length' field of the 'LinkedList', thus keeping track of the number of nodes in the list.
	ll.length++
}

// Prepend method adds a new node with the given data at the beginning of the list
func (ll *LinkedList[T]) Prepend(data T) {
	newNode := &Node[T]{data: data, next: ll.head}
	ll.head = newNode
	ll.length++
}

// PrintListData method prints the data of each node in the list .
func (ll *LinkedList[T]) PrintListData() {
	current := ll.head
	for current != nil {
		fmt.Printf("%v ", current.data)
		current = current.next
	}
	fmt.Println()
}

// String method returns a string representation of the list . 
func (ll *LinkedList[T]) String() string {
	return fmt.Sprint(ll.length)
}

func main() {
	// Nodes containing integer values
	integerList := LinkedList[int]{}
	integerList.Prepend(2)
	integerList.Prepend(1)
	integerList.Append(3)

	fmt.Printf("There are %s nodes containing the following values: ", integerList.String())
	integerList.PrintListData()

	// Nodes containing string values
	stringList := LinkedList[string]{}
	stringList.Append("'Hello'")
	stringList.Append("'World'")
	stringList.Append("'!'")

	fmt.Printf("There are %s nodes containing the following values: ", stringList.String())
	stringList.PrintListData()
}

There are 3 nodes containing the following values: 1 2 3 
There are 3 nodes containing the following values: 'Hello' 'World' '!'