Creating handlers from an interface

Let's say I have this interface

type Selecter interface {
	Select(vars ...string) error
}

and I want to make handlers that pretty much just return JSON forms of that interface after it has called the Select function. Like this:

func MakeHandler(s Selecter) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		//... do some stuff to get vars ...
		if err := s.Select(v1, v2); err != nil {
			//... blah blah errors ...
		}
		b, err := json.Marshal(s)
		if err != nil {
			//... blah blah errors ...
		}
		w.Write(b)
	}
}

So if CoolType is a Selecter I can do something like this

type CoolType struct {
	CoolString string `json:"cool_string"`
	CoolInt int 	  `json:"cool_int"`
	CoolBool bool 	  `json:"cool_bool"`
}

func (c *CoolType) Select(vars ...string) error {
	// fill up c using vars
	return nil
}

// this looks kinda ugly to me too
fn := MakeHandler(CoolType{})

The underlying problem I have with this is that s is an interface and uses a pointer. This would make this not safe in goroutines since s could be modified between the calls to Select and the call to Marshal.

I really think this is the way I'd like to go about implementing this since it is fairly concise and easy for me to change, but I think I'm missing something. I could use reflect or change the Selecter interface to have Select return an interface{} instead since I don't particularly care what the type is. Then I'd just make a new copy of the type in every implementation of Select I guess. Or a mutex would work. Or perhaps the better way to do this would be to have all of my Selecter types just implement ServeHTTP and be an http.Handler.

Anyway I assume people have tried something like this and have come up with possibly more elegant solutions so I'd like to hear some ideas.

If you are afraid of mutations pass a copy of the value. To do it you probably have to change your interface to something like:

type Selecter interface {
    Select(vars ...string) (Selecter, error)
}

And change your Select method to take a value receiver to fulfill the interface. It would be func (c CoolType) Select(vars ...string) (CoolType, error)

Then pass your s as a value instead of pointer and call Select like:

if s, err := s.Select(v1, v2); err != nil {
     //... blah blah errors ...
}

You can argue that you lose information about the type, but you already lost it while passing the value as a Selecter interface.

But in general your implementation is good. My feeling is that in Go elegant is something different than in other languages. I'd say that in Go elegant is readable, maintainable and accurate - not bureaucracy and trying to protect you from yourself.