Using an interface within a struct in Go

Question

In trying to understand Go, I ran into this piece of code in websocket.go (snipped):

type frameHandler interface {
    HandleFrame(frame frameReader) (r frameReader, err error)
    WriteClose(status int) (err error)
}

// Conn represents a WebSocket connection.
type Conn struct {
    config  *Config
    request *http.Request
    .
    .
    frameHandler
    PayloadType        byte
    defaultCloseStatus int
}

In the Conn type the frameHandler stands there all alone? An interface without a name? Later on in the code they even try check if the poor interface is nil:

Conn(a).frameHandler == nil

My own guess is that the frameHandler within the struct is a type which matches the frameHandler interface, and on top of that will have the name frameHandler. Is this correct? Hehe, fun language anyhow.

ruakh · Accepted Answer · 2012-02-23 22:06:23Z

This line:

    frameHandler

is roughly equivalent to this:

    frameHandler frameHandler

in that frameHandler is both the name of the field and its type. In addition, it adds all the fields and methods of the frameHandler to the Conn, so if conn is a Conn, then conn.WriteClose(0) means conn.frameHandler.WriteClose(0).

As the Go Programming Language Specification puts it:

A field declared with a type but no explicit field name is an anonymous field (colloquially called an embedded field). Such a field type must be specified as a type name T or as a pointer to a non-interface type name *T, and T itself may not be a pointer type. The unqualified type name acts as the field name.
// A struct with four anonymous fields of type T1, *T2, P.T3 and *P.T4
struct {
    T1        // field name is T1
    *T2       // field name is T2
    P.T3      // field name is T3
    *P.T4     // field name is T4
    x, y int  // field names are x and y
}
The following declaration is illegal because field names must be unique in a struct type:
struct {
    T         // conflicts with anonymous field *T and *P.T
    *T        // conflicts with anonymous field T and *P.T
    *P.T      // conflicts with anonymous field T and *T
}
Fields and methods (§Method declarations) of an anonymous field are promoted to be ordinary fields and methods of the struct (§Selectors). The following rules apply for a struct type named S and a type named T:

If S contains an anonymous field T, the method set of S includes the method set of T.

If S contains an anonymous field *T, the method set of S includes the method set of *T (which itself includes the method set of T).

If S contains an anonymous field T or *T, the method set of *S includes the method set of *T (which itself includes the method set of T).

A field declaration may be followed by an optional string literal tag, which becomes an attribute for all the fields in the corresponding field declaration. The tags are made visible through a reflection interface but are otherwise ignored.
// A struct corresponding to the TimeStamp protocol buffer.
// The tag strings define the protocol buffer field numbers.
struct {
    microsec  uint64 "field 1"
    serverIP6 uint64 "field 2"
    process   string "field 3"
}

Okay, then it was as I suspected. Can you do like that with types as well? myInt would be equal to myInt myInt? Ah! Your addition just answered my second thought.
Thanks for the help. The language surely has it its fun ways.
Also note that the methods of frameHandler are automatically also methods of Conn.
@AnschelSchaffer-Cohen: Good point. My answer is not really accurate in saying that those two forms are equivalent, since the first does more than the second. I'll see about editing it.

Collectives™ on Stack Overflow

Using an interface within a struct in Go

1 Answer 1

4 Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

4 Comments

Related