How to convert a struct to a different struct with fewer fields

I am trying to copy a struct of type Big to type Small without explicitly creating a new struct of type Small with the same fields.

I have tried searching for other similar problems such as this and this yet all the conversions between different struct types happen only if the structs have the same fields.

Here is an example of what I tried to do:

// Big has all the fields that Small has including some new ones.
type Big struct {
    A int
    B string
    C float
    D byte
}

type Small struct {
    A int
    B string
}

// This is the current solution which I hope to not use.
func ConvertFromBigToSmall(big Big) Small {
    return Small{
        A: big.A,
        B: big.B,
    }
}

I expected to be able to do something like this, yet it does not work:

big := Big{}
small := Small(big)

Is there a way of converting between Big to Small (and maybe even vice-versa) without using a Convert function?

Solution

There is no built-in support for this. If you really need this, you could write a general function which uses reflection to copy the fields.

Or you could redesign. If Big is a Small plus some other, additional fields, why not reuse Small in Big?

type Small struct {
    A int
    B string
}

type Big struct {
    S Small
    C float
    D byte
}

Then if you have a Big struct, you also have a Small: Big.S. If you have a Small and you need a Big: Big{S: small}.

If you worry about losing the convenience of shorter field names, or different marshalled results, then use embedding instead of a named field:

type Big struct {
    Small // Embedding
    C float
    D byte
}

Then these are also valid: Big.A, Big.B. But if you need a Small value, you can refer to the embedded field using the unqualified type name as the field name, e.g. Big.Small (see Golang embedded struct type). Similarly, to create a Big from a Small: Big{Small: small}.