Can Properties struct methods be inherited within the Node struct without embedding Properties in Go?

Embedded Structs

In Go, embedded structs offer a mechanism for reusing methods between structs. However, certain limitations arise when attempting to inherit methods without direct embedding.

Inquiring about Alternative Methods

A user poses the question: is it possible to inherit Properties struct methods within the Node struct without embedding Properties? The example code provided demonstrates embedded structs, leading to the concern of initializing Properties within Node.

Addressing the Key Clarification

The user's ultimate goal is to define Node as a Properties struct, eliminating the need for initializations within Node. The desired code would resemble the following:

<code class="go">package main

import "fmt"

type Properties map[string]interface{}

func (p Properties) GetString(key string) string {
    return p[key].(string)
}

type Nodes map[string]*Node

type Node Properties

func main() {
    allNodes := Nodes{"1": &Node{"test": "foo"}}
    singleNode := allNodes["1"]
    fmt.Println(singleNode.GetString("test"))
}</code>

Understanding Go's Design Choice

However, the user encounters a Go idiosyncrasy: embedding is the sole method for promoting methods from one struct to another. While it seems logical that Node structured as Properties should expose Properties methods, the syntax instead assigns Node the Properties layout, excluding methods.

Examining Go's Specification

Referencing the Go specification, the following statement clarifies the situation:

"The method set of an interface type is its interface. The method set of any other type T consists of all methods declared with receiver type T."

Thus, GetString, having a receiver type of Properties, excludes Node.

Additional Specifications for Anonymous Fields

The specification elaborates on anonymous fields (like Properties within Node):

"Promoted methods are included in the method set of the struct as follows:

• If S contains an anonymous field T, the method sets of S and *S both include promoted methods with receiver T.
• If S contains an anonymous field T, the method sets of S and S both include promoted methods with receiver T or *T."

Unfortunately, this results in the forced declaration of Properties within every Node.

Conclusion

In summary, while embedded structs provide a means for method inheritance, direct embedding is the only available approach in Go. The specifications prohibit the desired behavior without embedding.

The above is the detailed content of Can Properties struct methods be inherited within the Node struct without embedding Properties in Go?. For more information, please follow other related articles on the PHP Chinese website!