What are the several built-in supports in Go?

Go provides numerous built-in features that make it particularly well-suited for modern software and systems programming. Here are some of the key built-in features with corresponding examples:

1. **Concurrency Support (Goroutines and Channels) One of Go's major features is its native concurrency support, primarily through goroutines and channels. Goroutines are lightweight threads managed by the Go runtime. Channels are used for safely passing data between goroutines.

   Example: Suppose we want to download files concurrently from multiple websites; using goroutines makes this very straightforward:

   go
   func downloadSite(url string, ch chan<- string) {
       // Assuming this is the download logic
       ch <- url + " finished downloading"
   }
   
   func main() {
       urls := []string{"http://example.com", "http://example.org", "http://example.net"}
       ch := make(chan string)
   
       for _, url := range urls {
           go downloadSite(url, ch)
       }
   
       for range urls {
           fmt.Println(<-ch)  // Output download results
       }
   }

2. **Memory Management (Garbage Collection) Go features automatic garbage collection (GC), meaning developers do not need to manually manage memory, reducing the risk of memory leaks and other memory-related errors.

   Example: In Go, you can create objects without worrying about releasing memory later:

   go
   type Person struct {
       Name string
       Age  int
   }
   
   func newPerson(name string, age int) *Person {
       p := Person{Name: name, Age: age}
       return &p
   }

3. **Standard Library Go provides a rich standard library covering areas such as network programming, encryption, data processing, and text processing.

   Example: Using the net/http package to create a simple HTTP server:

   go
   package main
   
   import (
       "fmt"
       "net/http"
   )
   
   func helloWorld(w http.ResponseWriter, r *http.Request) {
       fmt.Fprintln(w, "Hello, world!")
   }
   
   func main() {
       http.HandleFunc("/", helloWorld)
       http.ListenAndServe(" :8080", nil)
   }

4. **Interfaces Go's interfaces provide a way to define object behavior without knowing the specific type, which is useful for designing large systems or for dependency injection.

   Example: Define an Animal interface and two structs Dog and Cat that implement it:

   go
   type Animal interface {
       Speak() string
   }
   
   type Dog struct{}
   func (d Dog) Speak() string {
       return "Woof!"
   }
   
   type Cat struct{}
   func (c Cat) Speak() string {
       return "Meow!"
   }
   
   func main() {
       animals := []Animal{Dog{}, Cat{}}
       for _, animal := range animals {
           fmt.Println(animal.Speak())
       }
   }

These are just some of the built-in features of Go; there are many others, such as error handling and reflection, that greatly enhance Go's utility and flexibility.