package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Welcome to the Go server!")
    })

http.ListenAndServe(":8080", nil

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world")
    say("hello"

    package main

    import (
        "encoding/json"
        "fmt"
        "os"
    )

    type Response struct {
        Page   int      `json:"page"`
        Fruits []string `json:"fruits"`
    }

    func main() {
        res := &Response{
            Page:   1,
            Fruits: []string{"apple", "peach", "pear"}}
        resJson, _ := json.Marshal(res)
        fmt.Println(string(resJson))

        str := `{"page": 1, "fruits": ["apple", "peach"]}`
        res = &Response{}
        json.Unmarshal([]byte(str), res)
        fmt.Println(res

    package main

    import (
        "database/sql"
        _ "github.com/lib/pq"
        "log"
    )

    func main() {
        connStr := "user=postgres dbname=postgres sslmode=disable"
        db, err := sql.Open("postgres", connStr)
        if err != nil {
            log.Fatal(err)
        }
        defer db.Close

  package main

    import (
        "bufio"
        "fmt"
        "os"
    )

    func main() {
        file, err := os.Open("file.txt")
        if err != nil {
            panic(err)
        }
        defer file.Close()

        scanner := bufio.NewScanner(file)
        for scanner.Scan() {
            fmt.Println(scanner.Text())
        }

        if err := scanner.Err(); err != nil {
            panic(err

package main

    import (
        "fmt"
        "net/http"
    )

    func loggingMiddleware(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            fmt.Println("Request received")
            next.ServeHTTP(w, r)
        })
    }

    func mainHandler(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hello, World!")
    }

    func main() {
        mainHandler := http.HandlerFunc(mainHandler)
        http.Handle("/", loggingMiddleware(mainHandler))
        http.ListenAndServe(":8080", nil

package main

    import "fmt"

    type Greeter interface {
        Greet() string
    }

    type English struct{}

    func (e English) Greet() string {
        return "Hello!"
    }

    type Spanish struct{}

    func (s Spanish) Greet() string {
        return "¡Hola!"
    }

    func GreetSomeone(g Greeter) {
        fmt.Println(g.Greet())
    }

    func main() {
        english := English{}
        GreetSomeone(english)
        spanish := Spanish{}
        GreetSomeone(spanish

package main

import "fmt"

func main() {
    messages := make(chan string)

    go func() { messages <- "ping" }()

    msg := <-messages
    fmt.Println(msg

    package main

    import (
        "errors"
        "fmt"
    )

    func doSomething() error {
        // An error occurred
        return errors.New("something went wrong")
    }

    func main() {
        if err := doSomething(); err != nil {
            fmt.Println(err

    package main

    import (
        "testing"
    )

    func Sum(x int, y int) int {
        return x + y
    }

    func TestSum(t *testing.T) {
        total := Sum(5, 5)
        if total != 10 {
        t.Errorf("Sum was incorrect, got: %d, want: %d.", total, 10