How to create a copy of a struct only having interface it implements and it's value

Let's say I have this A struct that implements Setter interface:

type Setter interface {
    Set(key string, value string)
}

type A struct {
    m map[string]string
}

func (a *A) Set(key string, value string) {
    a.m[key] = value
}

And I have one different struct that holds some implementation of Setter interface

type Holder struct {
    val Setter
}

h := Holder{
    val: &A{ map[string]string{} },
}

What i need is to get a copy of the h.val struct with all values saved.

I have already tried the following solution but it did not work, resulting with panic: assignment to entry in nil map

(We have defined the map when initiallizing h, so by running h.val.Set(k, v) we won't get any errors)

l := reflect.New(
    reflect.ValueOf(h.val).Elem().Type(),
).Interface().(Setter)

l.Set("A", "B")

How can I create a copy of a struct without knowing which fields it consists of, only knowing the interface it implements and having it's value in a variable?

p.s. Adding Clone method to Setter interface is not a preferred solution

> Adding Clone method to Setter interface is not a preferred solution

in all generality, since only the Setter implementation knows how it should be "cloned", there isn't much choice.

For example : should "cloning" an A struct create a new struct pointing at the same mapping ? or should it duplicate the mapping ?

If your intention is really to clone, you probably want the second, but you can see it will quickly fall outside the scope of a simple reflect operation.

If your code actually only deals with A structs, you may pass explicit A values. You will probably still need a .Clone() method or a Clone(a *A) function.

If your only issue is that a zero value for A is invalid, you can fix Set() :

func (a *A) Set(key string, value string) {
    if a.m == nil {
        a.m = make(map[string]string)
    }
    a.m[key] = value
}