Why am I getting "declared but not used"?

I'm taking "a tour of Go" and for one of the exercises I've written this function:

func Sqrt(x float64) float64 {
	z := 1.0
	var prev_z float64
	for (z - prev_z) != 0 {
		prev_z := z
		z -= (z*z - x) / (2*z)
		fmt.Println(z)
	}
	return z
}

Why does this give me "prev_z declared but not used"?

Because you are declaring a variable (prev_z) of type float64 inside the for loop. and after that you are again initializing a new variable with the same name and type using the := short declaration operator(in line 5).

below is the correct code:

func Sqrt(x float64) float64 {
z := 1.0
var prev_z float64
for (z - prev_z) != 0 {
    prev_z = z
    z -= (z*z - x) / (2*z)
    fmt.Println(z)
}
return z

}

The issue in your code is that you're using the := operator to re-declare prev_z inside the for loop. This actually creates a new prev_z variable with a narrower scope that shadows the original prev_z variable declared outside of the loop. Since this new variable is never used, you get the "prev_z declared but not used" error, you should use the = operator instead of := inside the loop to assign the new value to the existing prev_z

This should work below

func Sqrt(x float64) float64 {
z := 1.0
var prev_z float64
for (z - prev_z) != 0 {
    prev_z = z
    z -= (z*z - x) / (2*z)
    fmt.Println(z)
}
return z

}

Whenever you use := , It generates new variable on fly and infer data type of that variable from the value that is present on Right hand side of this operator. So if you write:

a:=1

Then you're essentialy creating variable name a of type int.
In your code inside for loop you've written:

prev_z := z

Which leads to the creation of new variable with name prev_z which overshadows prev_z in outer context and hence it gets remained unused.

Just as a complement to other commenters. The name of this phenomenon is variable shadowing. It's a common mistake to use it unintentionally, especially when you have conditionals and functions that return errors as second arguments inside if/for blocks.

This example from the book 100 Go Mistakes and How to Avoid Them (worth reading, btw) illustrates a case of variable shadowing that results in an always nil variable:

> var client *http.Client ❶
> if tracing {
> client, err := createClientWithTracing() ❷
> if err != nil {
> return err
> }
> log.Println(client)
> } else {
> client, err := createDefaultClient() ❸
> if err != nil {
> return err
> }
> log.Println(client)
> }
> // Use client
>
> In this example, we first declare a client variable. Then, we use the
> short variable declaration operator (:=) in both inner blocks to
> assign the result of the function call to the inner client
> variables—not the outer one. As a result, the outer variable is always
> nil.
>
> NOTE This code compiles because the inner client variables are used in
> the logging calls. If not, we would have compilation errors such as
> client declared and not used.

In your case it's just one variable, so you just don't reassign prev_z with the short assignment operator :=.
But in the case of two or more variables, you could use temporary variables inside the if/for block or declare the variables outside of the block.