# 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.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://ineelhere.gitbook.io/code-with-go/23-generics.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.