# Generics

This Go program defines a generic function `MapKeys` and a generic linked list `List`.

The `MapKeys` function takes a map and returns a slice containing all the keys of the map.

The `List` type is a generic linked list with methods to push elements and retrieve all elements.

Let's go through each part of the code with inline comments and additional explanations:

```go
package main

import "fmt"

// MapKeys is a generic function that takes a map and returns a slice containing all keys of the map.
func MapKeys[K comparable, V any](m map[K]V) []K {
    r := make([]K, 0, len(m))
    for k := range m {
        r = append(r, k)
    }
    return r
}

// List is a generic linked list with elements of type T.
type List[T any] struct {
    head, tail *element[T]
}

// element is a generic element in the linked list.
type element[T any] struct {
    next *element[T]
    val  T
}

// Push adds a new element to the end of the list.
func (lst *List[T]) Push(v T) {
    if lst.tail == nil {
        lst.head = &element[T]{val: v}
        lst.tail = lst.head
    } else {
        lst.tail.next = &element[T]{val: v}
        lst.tail = lst.tail.next
    }
}

// GetAll returns all elements in the list as a slice.
func (lst *List[T]) GetAll() []T {
    var elems []T
    for e := lst.head; e != nil; e = e.next {
        elems = append(elems, e.val)
    }
    return elems
}

func main() {
    // Create a map with integer keys and string values
    var m = map[int]string{1: "2", 2: "4", 4: "8"}

    // Call the MapKeys function to retrieve all keys of the map and print them
    fmt.Println("keys:", MapKeys(m))

    // Another way to call MapKeys with explicit types
    _ = MapKeys[int, string](m)

    // Create a generic linked list of integers
    lst := List[int]{}
    lst.Push(10)
    lst.Push(13)
    lst.Push(23)

    // Retrieve all elements from the list and print them
    fmt.Println("list:", lst.GetAll())
}
```

#### Output

```
keys: [1 2 4]
list: [10 13 23]
```

Explanation:

1. The `MapKeys` function is a generic function that accepts a map with keys of type `K` and values of type `V`. It iterates over the keys of the map and appends them to a slice, which is then returned.
2. The `List` type is a generic linked list that contains elements of type `T`. It has a `head` and `tail` pointers to keep track of the list.
3. The `element` type is a generic struct representing an element in the linked list, with a `next` pointer to the next element and a `val` field representing the value of the element.
4. The `Push` method of the `List` type adds a new element to the end of the linked list.
5. The `GetAll` method of the `List` type retrieves all elements from the linked list and returns them as a slice.
6. In the `main` function, a map with integer keys and string values is created, and the `MapKeys` function is used to retrieve and print all keys of the map.
7. Another way to call `MapKeys` is shown with explicit types.
8. A generic linked list of integers is created, elements are pushed onto the list, and all elements are retrieved and printed using the `GetAll` method.