[go-nuts] can't use pointers to interface types?

This works.

interface{} is just 2 words, copying it is very cheap.
interface copy does not copy the stored object, interface assignment can

No, it doesn't. See http://play.golang.org/p/FpInrZULnU

I don't understand this.

no, it does:
http://play.golang.org/p/ohUkWqzAQo
interface copy is cheap

Just to clarify here, interface copy is cheap only if the value it stores
is <= one word, which includes pointers. If you store a large struct value
in an interface (not pointer), it will cause the underlying value to get
copied when you pass it around.

That's not true.
If the value is larger than a pointer then it will be allocated on the
heap somewhere and a pointer stored in the interface value.
Since you can't address that value from your code, it's safe for the
compiler not to copy that value each time you copy the interface
value.

Just to make that concrete, here you can see that behaviour; the copy only happens when a concrete version is requested by an assertion.

http://play.golang.org/p/oYohb0I91Y

Thanks for the clarification. I'm glad to hear about this current behavior.
I got confused by a conversation in a different mailing list that led me to
believe that this was not the case.

What I wrote is broadly correct, but sublty misinterprettable; any action that makes the interface concrete has the same effect, as can be seen here http://play.golang.org/p/XKI047WWzd

On 08/07/2014, at 3:55 AM, "Sugu Sougoumarane" wrote:

Thanks for the clarification. I'm glad to hear about this current behavior.
I got confused by a conversation in a different mailing list that led me to believe that this was not the case.

On Saturday, July 5, 2014 12:18:48 AM UTC-7, kortschak wrote:
Just to make that concrete, here you can see that behaviour; the copy only happens when a concrete version is requested by an assertion.

http://play.golang.org/p/oYohb0I91Y

Function calls in Go (like most other languages) is 'pass by value'.
The values passed to the function are copied on to the stack for the
function to access.
In languages without complex values type (i.e. structs) these values
are either primitive values (ints, floats etc) or they are
references(pointers) to objects.

Interface values in Go are the size of two pointers, one pointer to
type information and the other is a pointer to the value currently
stored in the interface value. eg. an io.Reader that you've assigned
an *os.File to will contain that *os.File pointer and a pointer to the
*os.File type information.

Passing interface values to a function copies the interface value.

Also, read http://research.swtch.com/interfaces.

If I read correctly, a value of type interface is a wrapper with a pointer
to the real thing. So when I would use a pointer to the real thing as an
argument to a function, I can get the same effect by passing the interface
value itself, because it already is a pointer (conceptually).

Is this correct?

If so, is this part of the language design, or is it just how it happens to
be implemented in the Go compiler. In other words, can I rely on an
interface value always acting like a pointer to the real thing, or might it
change in another implementation?

Or with the real thing itself, if it will fit in a pointer-sized slot.

So when I would use a pointer to the real thing as an argument to a
No. A pointer will let you update the variable it points to. The value
in the interface is a copy of the thing it was assigned from, just like
ordinary assignment/parameter-passing.

Also, interfaces give you polymorphism, and pointers do not.

If so, is this part of the language design, or is it just how it happens to
You can rely on the value stored in an interface being a copy, just like
a variable of the appropriate type.

And you can probably rely on the implementors not randomly discarding
a nice space optimisation.

Chris

Then what is happening here? http://play.golang.org/p/8TkDe-0Gw-

Why should there be a '*' in the definition of p1, and not in that of p2?

p1 gets the pointer os.Stdout.
What does p2 get? Something that embeds that pointer? Or something that
embeds a copy of that pointer?

p1 needs a parameter that is a pointer to an os.File. os.Stdout is a
pointer to an os.File.
p2 needs *something* that implements the io,.Writer interface. That
"something" might be a pointer, might not be. In your case, it is, since
the Write method the File struct needs a pointer receiver, so you *have* to
pass in a pointer to os.File to satisfy the io.Writer interface.

It generally doesn't make sense to declare a function that takes a pointer
to an interface, e.g. *io.Writer. It's not very useful - io.Writer itself
might *contain* a pointer (as in your p2) example and all is fine.

I think you may be confused about what interfaces in Go are and how they
work. These might help:
http://golang.org/doc/faq#pointer_to_interface
http://golang.org/doc/faq#different_method_sets