static rivet
func Printf(format string, a ...interface{}) (n int, err error) {
return Fprintf(os.Stdout, format, a...)
}
I don't understand what the meaning of a ...interface{}. I also don't get why the return signature is specifying that it will return an integer and an error but the return is actually a function (Fprintf).
This comes from this tutorial (https://quii.gitbook.io/learn-go-with-tests/go-fundamentals/dependency-injection) and it's not clicking...
visual pike
```
func Printf(format string, a ...interface{}) (n int, err error) {
return...
a ...T means it accepts 0 or more things of T and a will be a slice of them ([]T)
also the things its returning is still int, error because it's calling Fprintf and that returns int, error
static rivet
@visual pike Thanks
can you explain why I HAVE to pass &buffer instead of just passing the buffer itself into Greet() ??
buffer := bytes.Buffer{}
Greet(&buffer, "Chris")
got := buffer.String()
want := "Hello, Chris"
if got != want {
t.Errorf("got %q want %q", got, want)
}
func Greet(writer io.Writer, name string) {
fmt.Fprintf(writer, "Hello, %s", name)
}
}```yea sure,
first of all it needs to store current offset etc, thus it requires it to mutate the buffer variable, and the way to do this in go is a pointer
static rivet
yea sure,
first of all it needs to store current offset etc, thus it requires it...
So when Greet(buffer, "Chris") is called, Greet() creates a copy of buffer that isn't writable, I can kind of see that part but I don't get why this copy wouldn't have the same characteristics (an offset) as the one being referenced inside the TestGreet function.
cannot use buffer (variable of type bytes.Buffer) as io.Writer value in argument to Greet: bytes.Buffer does not implement io.Writer (method Write has pointer receiver) How does this not impliment io.Writer when passed as a variable but it does when referenceed as a pointer??
visual pike
So when `Greet(buffer, "Chris")` is called, Greet() creates a copy of buffer tha...
im not explaining it very well, but it is writable, it's just that it's limited and won't modify the original variable
for this reason, Read and Write are implemented as a pointer receiver
static rivet
buffer := bytes.Buffer{} //create variable with an empty buffer
fmt.Println(buffer)//Empty
Greet(&buffer, "Chris") //fill the buffer
fmt.Println(&buffer)// {[72 101 108 108 111 44 32 67 104 114 105 115] 0 0}
fmt.Println(buffer) //Hello, Chris
I'm not sure how to interpret this behavior or why the pointer would implement io.Writer() but the variable (which is a copy inside Greet()) doesn't.
visual pike
`buffer := bytes.Buffer{}` //create variable with an empty buffer
`fmt.Println(...
how would you make a write without pointer receivers?
static rivet
Still don't understand. I guess ill just make it a rule that a Writer is always a pointer and leave it at that.