Golang pointer receiver technicalities confusion - c

Question

I recently started to learn Golang for a work project. I come from a 'c' background and have some confusion about the technicalities of Pointer Receivers in functions. Am I to assume receiver are generalized and don't care if the object is actually a pointer or a literal, it will translate it to whatever the receiver type is.
I know my question wording may be confusing so here is some code for example:
func (v *clients) makePtr() {
(*v).slice = make([]client, 0)
return
}
func (v clients) makeLit() []client {
return make([]client, 0)
}
func main() {
clsPtr := &clients{} // pointer
clsLit := clients{} // literal
clsLit.makePtr() // literal with pointer reciever
clsLit.makeLit() // literal with pointer reciever
clsPtr.makePtr() // pointer with literal reciever
clsPtr.makeLit() // pointer with pointer reciever
}
I expected the the functions with pointer receivers to only work on pointers and vice versa. from this am I just suppose to assume receivers are a blanket statement and don't care if its a pointer, literal?
EDIT:
Apologizes guys, I may not have been to clear with my question, I understand that a pointer receiver is used to modify a object but I'm more confused as to the syntax, why does a pointer receiver work for both a literal and a pointer, since it receives a pointer shouldn't it only work on a pointer?

Answer 1

The pointer receiver means if you mutate the object on the method it will change the underlying struct.
When you call it, it doesnt make a difference.
package main
import (
"fmt"
)
type data struct {
val int
}
func (d data) changeNonPersistent(newval int) {
d.val = newval
}
func (d *data) changePersistent(newval int) {
d.val = newval
}
func main() {
// initialize both ptr and val version to 5
dptr := &data{val: 5}
dval := data{val: 5}
fmt.Println(*dptr)
fmt.Println(dval)
// non persistent val change to 10
dptr.changeNonPersistent(10)
dval.changeNonPersistent(10)
fmt.Println("Non Persistent-")
fmt.Println(*dptr)
fmt.Println(dval)
// persistent val change to 15
dptr.changePersistent(15)
dval.changePersistent(15)
fmt.Println("Persistent-")
fmt.Println(*dptr)
fmt.Println(dval)
}
or see the code here https://play.golang.org/p/jwOUwsso3PZ
tl;dr; the object or reference does not make a difference, as long as the receiver is right.
And you usually only want to have pointer receiver if your goal is to mutate. Other wise just send a copy.

Answer 2

In golang these are called methods which are function with receiver.
The receiver argument can be passed by value or by pointer.
You can write functions like below which are plain functions.
type Client struct{}
//A pointer to Client
func makePtr(c *Client){
//do something with c
}
//A copy of client is made.
func makeLit(cs Client){
//do something with c
}
Instead if you write methods then it gives association with struct.
type Client struct{}
func (c *Client) makePtr(){
//do something with c
}
//A copy of client is made.
func (c Client)makeLit(){
//do something with c
}
The main purpose of methods I see in golang is for interface implementation
It is by virtue of methods structs implement (or satisfy) interfaces.