Cannot use (type []byte) as type io.Reader

I think you are missing a step in your logic when you think that []byte would be equivalent to Reader just because the Reader's Read method receives a []byte as a parameter.

Let me try to clarify:

Your ReceiveSnapshot function expects a Reader as a parameter:

ReceiveSnapshot( input io.Reader ...

In order for a type to fulfil the Reader interface, that type should itself implement this function:

Read(p []byte) (n int, err error)

Note that the type should implement that function in order to be a Reader.

[]byte does not implement a Read function. It is just a coincidence that the argument to Read happens to be a []byte.

In order for this to work, you need to send ReceiveSnapshot a proper Reader.

Luckily for you, having a []byte and wanting to Read for it is a common situation so the API provides an easy way to do this:

https://golang.org/pkg/bytes/#NewReader

You just need to send bytes.NewReader(buff) to your ReceiveSnapshot function instead of just buff.

Short answer: Wrap your buffer in a Reader type by using bytes.NewReader

Alternatively, you could use bytes.NewBuffer with similar effect.

If the source is a string, you can use strings.NewReader.

The list of Readers goes on and on: https://golang.org/search?q=Read#Global

---

Explanation of the deeper question

The deeper question being: Why doesn't an array support the io.Reader interface directly?

io.Reader supports the concept of reading from a general data stream for which the total size is not necessarily known in advance. In order to support this, Read is called repeatedly until all input data is exhausted. In many languages, similar read functions must be called at least twice, where the final call returns a flag indicating end-of-file.

By returning two values (one of which is type error), Go makes it possible for reading of arrays to complete in one-shot, but only if the destination buffer is large enough to consume all available data -- which isn't always known in advance.

The io.Reader interface specifies the signature and behavior of the Read() function:

func (T) Read(b []byte) (n int, err error)

Read populates the given byte slice with data and returns the number of bytes populated and an error value. It returns an io.EOF error when the stream ends.

So due to the way the io.Reader interface works, a simple byte buffer is not capable of implementing it. A wrapper structure is required in order to remember the state between subsequent calls to Read().

For the sake of interest, here's an example showing how that can be implemented...

type MyReader struct {
    src []byte
    pos int
}

func (r *MyReader) Read(dst []byte) (n int, err error) {
    n = copy(dst, r.src[r.pos:])
    r.pos += n
    if r.pos == len(r.src) {
        return n, io.EOF
    }
    return
}

func NewMyReader(b []byte) *MyReader { return &MyReader{b, 0} }

Notice, also, that the []byte parameter to Read() is the destination buffer, not the source.