How to embed third-party types in Go?

In the Go language, embedding third-party types is a powerful feature that allows us to extend and customize existing types without modifying the original code. By embedding third-party types, we can inherit their methods and properties to achieve code reuse and extension. This article will introduce you to how to embed third-party types in the Go language and give some examples of practical application scenarios. Whether you are a beginner of Go language or an experienced developer, I believe this article can provide you with practical guidance.

Question content

In my application, the decimal package github.com/shopspring/decimal is used.

To write custom functions on the decimal.decimal type, I created my own decimal type and embedded decimal.decimal:

type decimal struct {
    decimal.decimal
}

This works great, I can now access methods on the decimal object:

a := decimal{decimal.newfromfloat(1.0)}
b := decimal{a.neg()}

Some decimal.decimal methods require parameters of type decimal.decimal, f.ex:

c := decimal{a.add(b)}

The above line does not compile due to the error: cannot use b (variable of type decimal) as decimal. a.addDecimal value in parameter

I tried converting decimal to decimal.decimal:

c := decimal{a.add((decimal.decimal)(b))}

The above code cannot be compiled due to the following error:

cannot convert b (variable of type Decimal) to decimal.Decimal

Question: How to extend/embed a third party type in a way that allows the use of "parent" methods and can use the extended type as a parameter in the method Does this require a parent type argument? ?

Solution

Fields declared with a type but without an explicit field name are called embedded fields. The embedded field must be specified as a type name t or a pointer to a non-interface type name *t, and t itself may not be a pointer type. Unqualified type names act as field names.

So a quick and dirty solution is to simply use the "unqualified type name" to access the field.

_ = decimal{a.add(b.decimal)}

However, if you are looking for a more seamless experience when using the new type, your only option is to redeclare the method that requires the original type and use the new type in its place. These redeclared methods need only be simple wrappers around methods that pass the embedded fields of one instance to the embedded fields of another instance. For example:

type Time struct {
    time.Time
}

func (t Time) In(loc *time.Location) Time {
    return Time{t.Time.In(loc)}
}

func (t Time) Equal(u Time) bool {
    return t.Time.Equal(u.Time)
}

The above is the detailed content of How to embed third-party types in Go?. For more information, please follow other related articles on the PHP Chinese website!