
```go
func main() {
  fmt.Print("Print --> I don't add a new line")
  fmt.Println()
  fmt.Println("Println --> I do add a new line")
  fmt.Printf("Printf --> With the help of formatting verbs, I welcome dynamic variables, like %d\n", 5)
  // The following line will emit a warning: result of fmt.Sprintf call not used
  // fmt.Sprint("Sprint --> I don't print my static value to standard output")

  s := fmt.Sprint("Sprint --> I don't print my static value to standard output")
  fmt.Println(s)
  sf := fmt.Sprintf("SPrintf --> I don't print my dynamic value to standard output either, so you need to assign me to a variable first, then %d ", 5)
  fmt.Println(sf)
}

```

The output of the above code looks like this:

```
Print --> I don't add a new line
Println --> I do add a new line
Printf --> With the help of formatting verbs, I welcome dynamic variables, like 5
Sprint --> I don't print my static value to standard output
SPrintf --> I don't print my dynamic value to standard output either, so you need to assign me to a 5 first
```

To make it sound more formal:

- `fmt.Print` writes to the standard output, without a new line at the end.

- `fmt.Println` writes to the standard output (usually the console) and appends a newline character at the end. It takes a variable number of arguments and formats them using their default formatting.

- `fmt.Printf` is similar to fmt.Println, but it allows you to specify a custom format string. The syntax for a format string is %[flags][width][.precision]verb, where verb specifies the type of the argument (e.g. d for integers, f for floating-point numbers).

- `fmt.Sprint` formats its arguments and returns the resulting string, rather than printing it to the standard output.

- `fmt.Sprintf` is similar to fmt.Sprint, but it allows you to specify a custom format string.


Variants of Formatting methods in Go


```go
import (
	"encoding/json"
	"fmt"
	"strconv"
	"strings"
)

a := [7]string{"sun", "mon", "tues", "wednes", "thurs", "fri", "satur"}

res := make([]string, 0)
for i := range a {
		s := "DAY " + strconv.Itoa(i) + ": " + strings.Title(a[i]) + "day"
		res = append(res, s)
}

resB, _ := json.Marshal(res)
fmt.Println(string(resB))
```

- First, we declare a new array `a` of type [7]string, which means it can hold 7 string values. We also initialize it with the values of a partial name of days.

- Then, we create a new slice with a length of 0 and a capacity of 0.

- Then we use `range` to iterate over elements in the array `a`. As we don't need the value for each entry, we ignore the second argument and only specify the index `i`.

- Within the for loop, we declare and initialize a string with a formatted message, which would print something like "Day 1: Sunday". We use the `Itoa` function from the `strconv` package to convert an integer to string type, to allow the concatenation of two data structures (int and string). We also use a function in the built-in `strings` package to capitalize each day.

- Then, we use the `append` function, which does not modify the slice in place. Instead, it returns a new slice with the appended element(s). In order to append an element to the `res` slice, we will need to assign the returned slice back to the `res` variable. So we call the `append` function with the slice and the `s` variable as separate arguments.

- Then, we exit the loop and move on. To encode data in json, we use the `json.Marshal` function to convert the `res` slice into a JSON byte slice ([]byte). The \_ is known as the "blank identifier" and is used to discard the second return value of the `json.Marshal` function, which is an error value. If the function succeeds, the error value will be nil, so discarding it is safe in this case.

- Lastly, we convert the `resB` byte slice into a string and prints it to the console using the `fmt.Println` function. The output will be a JSON-formatted string representation of the `resB` slice, like so:

```
make run

["DAY 0: Sunday","DAY 1: Monday","DAY 2: Tuesday","DAY 3: Wednesday","DAY 4: Thursday","DAY 5: Friday","DAY 6: Saturday"]
```

To me, learning go is like learning how to express an abstract idea or an instruction in one line. However, if we want to go deep (pun intended :D), we should be able to expand this compact form into a narrative that is easy to follow.
