extending structs with (relatively) unknown/arbitrary methods, go reflection(or avoiding reflection)

The below does not work obviously:

Arbitrary := struct {
	field1 string
	field2 string
}{"a", "b"}

fmap := make(map[string]func(string) string)
fmap["fone"] = func(s string) string { fmt.Printf("function fone: %s", s) }
fmap["ftwo"] = func(s string) string { fmt.Printf("function ftwo: %s", s) }

// probably ok, as simple examples go, to this point where reflection needs to be used
// the below does not work 
Arbitrary.fone = fmap["fone"]

Arbitrary.fone("hello")

The above is the core of what I'm trying to do: create a struct with values, and then create methods on the struct from a map of functions, or functions passed in. Basically I have a structure with data & ambiguous behavior that needs to be extended with methods unknown until creating the type.

I'm looking for the obvious & inevitable:

1. How to do this in Go

2. Why this shouldn't be done, or can't be done in Go (its possible with the reflect package, I just haven't found examples or reasoned thorough it yet)

3. How this should be done in Go (some sort of interface construct I've not figured out wholly. I've tried an interface which can handle the behavior; but it doesn't account for other behaviors that might be added, at the least I haven't figured out interface usage fully yet which is part of the issue)

If you're a person needing complexity here is the start of the actual task I'm trying to accomplish, making that structs behavior extendable.

I completely misunderstood the question.

NO, you can't create a new struct out of thin air and assign fields to it, also even if you could, for the love of everything that's holy, don't do that.

You can use multiple interfaces for example:

type Base interface {
	Id() int //all structs must implement this
}
type Foo interface {
	Base
	Foo()
}
type Bar interface {
	Base
	Bar()
}

then make a map[string]Base, and you can assert the value later.

//leaving the original answer as a different approach to the problem.

<strike>While usually that kind of stuff is done using reflection, if you have a limited number of accepted "callbacks" you can use type assertion and an interface{} map, dropping the need for reflection.</strike>

var ctx = &Ctx{"Hello"}
var funcs = map[string]interface{}{
	"m3": ctx.Do,
	"m4": func(c *Ctx) { fmt.Println("ctx:", c) },
}

type Ctx struct {
	Name string
}

func (c *Ctx) Do() {
	fmt.Printf("Do: %+v\n", c)
}

func call(m string) {
	if f, ok := funcs[m]; ok {
		switch fn := f.(type) {
		case func():
			fn()
		case func(*Ctx):
			fn(&Ctx{"Hello world"})
		default:
			panic(fn)
		}
	}
}

<kbd>playground</kbd>