Sure! Let's break down the concept of actions in Go templates, represented by `{{ ... }}`, with examples for each type: variables, function calls, loops, conditionals, and more.

### 1. Variables

In Go templates, variables are placeholders that get replaced with actual data when the template is rendered. The data is typically passed to the template from the Go code.

#### Example:
```go
{{ .Title }}
```
Here, `{{ .Title }}` will be replaced by the value of the `Title` field in the data passed to the template.

#### Go Code:
```go
data := struct {
    Title string
}{
    Title: "Welcome to My Website",
}

tmpl.Execute(w, data)
```

#### Template:
```html
<!DOCTYPE html>
<html>
<head>
  <title>{{ .Title }}</title>
</head>
<body>
  <h1>{{ .Title }}</h1>
</body>
</html>
```

### 2. Function Calls

Go templates allow you to call functions to process data before rendering it. Built-in functions can be used directly in the template.

#### Example:
```go
{{ .Date | dateFormat "2006-01-02" }}
```
Here, `{{ .Date | dateFormat "2006-01-02" }}` formats the date using the `dateFormat` function.

#### Go Code:
```go
data := struct {
    Date time.Time
}{
    Date: time.Now(),
}

tmpl.Execute(w, data)
```

#### Template:
```html
<!DOCTYPE html>
<html>
<head>
  <title>Date Example</title>
</head>
<body>
  <p>{{ .Date | dateFormat "2006-01-02" }}</p>
</body>
</html>
```

### 3. Loops

Loops allow you to iterate over collections like arrays or slices.

#### Example:
```go
{{ range .Items }}
  <li>{{ . }}</li>
{{ end }}
```
Here, `{{ range .Items }}` loops through each item in the `Items` collection.

#### Go Code:
```go
data := struct {
    Items []string
}{
    Items: []string{"Item 1", "Item 2", "Item 3"},
}

tmpl.Execute(w, data)
```

#### Template:
```html
<!DOCTYPE html>
<html>
<head>
  <title>Loop Example</title>
</head>
<body>
  <ul>
    {{ range .Items }}
      <li>{{ . }}</li>
    {{ end }}
  </ul>
</body>
</html>
```

### 4. Conditionals

Conditionals are used to include or exclude parts of the template based on certain conditions.

#### Example:
```go
{{ if .IsAdmin }}
  <p>Welcome, admin!</p>
{{ else }}
  <p>Welcome, user!</p>
{{ end }}
```
Here, `{{ if .IsAdmin }}` checks if the `IsAdmin` variable is true.

#### Go Code:
```go
data := struct {
    IsAdmin bool
}{
    IsAdmin: true,
}

tmpl.Execute(w, data)
```

#### Template:
```html
<!DOCTYPE html>
<html>
<head>
  <title>Conditional Example</title>
</head>
<body>
  {{ if .IsAdmin }}
    <p>Welcome, admin!</p>
  {{ else }}
    <p>Welcome, user!</p>
  {{ end }}
</body>
</html>
```

### 5. Pipelines

Pipelines allow you to chain multiple operations together. Each operation's output becomes the input for the next operation.

#### Example:
```go
{{ .Price | multiply 1.1 | printf "%.2f" }}
```
Here, `{{ .Price | multiply 1.1 | printf "%.2f" }}` multiplies `Price` by `1.1` and then formats it to two decimal places.

#### Go Code:
```go
data := struct {
    Price float64
}{
    Price: 100.0,
}

tmpl.Execute(w, data)
```

#### Template:
```html
<!DOCTYPE html>
<html>
<head>
  <title>Pipeline Example</title>
</head>
<body>
  <p>Price: ${{ .Price | multiply 1.1 | printf "%.2f" }}</p>
</body>
</html>
```

### 6. Custom Functions

You can define custom functions in Go and pass them to the template.

#### Example:
Define a custom function to multiply a number:

```go
func multiply(a, b float64) float64 {
    return a * b
}
```

#### Go Code:
```go
func multiply(a, b float64) float64 {
    return a * b
}

func main() {
    tmpl := template.New("example").Funcs(template.FuncMap{
        "multiply": multiply,
    })

    tmpl, _ = tmpl.Parse(`
    <!DOCTYPE html>
    <html>
    <head>
      <title>Custom Function Example</title>
    </head>
    <body>
      <p>Price: ${{ .Price | multiply 1.1 }}</p>
    </body>
    </html>`)

    data := struct {
        Price float64
    }{
        Price: 100.0,
    }

    tmpl.Execute(os.Stdout, data)
}
```

### Conclusion

Go templates use `{{ ... }}` to perform various actions, including accessing variables, calling functions, iterating over collections, and evaluating conditions. This flexibility allows you to create dynamic, data-driven content easily. Understanding these actions helps you utilize the full power of Go templates effectively.