What's happening with these pointers?

I wrote some odd code, but I'm not sure why it works and what I can learn from it. I have a slice type build from another struct. I made a function on the slice type to modify itself. To do this, I seem to have to throw around *'s a little much.

I'm trying to learn about pointers in Go and would like a little help. Here's an example (http://play.golang.org/p/roU3MEeT3q):

var ClientNames = []string {"Client A", "Client B", "ClientC"}


type InvoiceSummaries []InvoiceSummary
type InvoiceSummary struct {
    Client string
	Amt    int
}

func (summaries *InvoiceSummaries) BuildFromAbove() {
    for _, name := range ClientNames {
	     *summaries = append(*summaries, InvoiceSummary{name, 100})
    }
}

My question is: What is the purpose for each of these * and why am I not using any &?

You have to use a pointer for the receiver - (summaries *InvoiceSummaries) - because otherwise the argument is passed by value, having a pointer means you pass a reference to the value instead. If not for that, then you couldn't modify the collection at all.

Inside of the methods body you have use * because it is the dereferncing operator and returns the value at the address. Ampersand (&) is the opposite, it gives the address of a value.

Nothing wrong with your code but normally addresses to slices aren't used. A slice is a small struct that gophers are normally happy to pass by value. If a method or function is creating a new slice, the gopher is happy to return the new slice, by value again, as the return value.

Of course passing a slice by value doesn't guarantee anything about the backing store remaining unchanged when the method/function returns. So it can't be used as a way of guaranteeing the data elements of the slice haven't mutated.

> What is the purpose for each of these * ?

By making the method receiver as pointer, you could easily change the property of the object. I think that's one of the benefit. This example below will prove it.

package main

import "fmt"

type someStruct struct {
    someVar int
}

func (s someStruct) changeVal1(newVal int) {
    s.someVar = newVal
}

func (s *someStruct) changeVal2(newVal int) {
    s.someVar = newVal
}

func main() {
    s := someStruct{0}
    fmt.Println(s) // {0}

    s.changeVal1(3)
    fmt.Println(s) // {0}

    s.changeVal2(4)
    fmt.Println(s) // {4}

    (&s).changeVal2(5)
    fmt.Println(s) // {5}
}

> and why am I not using any &?

Pointer method receiver is quite special, it can also be called from non-pointer struct object. Both of s.changeVal2(4) and (&s).changeVal2(5) are valid & will affect the value of someVar.

Example http://play.golang.org/p/sxCnCD2D6d