Prototyping struct in Go

My use case is, I need to have several structs in Go, who will have methods of same signatures and not necessarily have to have all the methods. The following code describes the requirements and also represents my current solution.

type calc struct {
    fn func(a, b int) int
    gn func(a string) bool
    name string
}

func add(a, b int) int {
    return a + b
}

func bar(foo string) bool {
    // do something
}

func sub(a, b int) int {
    return a - b
}

func main() {
    for c := range []calc{{
        fn: add,
        gn: bar,
        name: "addition",
    }, {
        fn: sub,
        name: "subtraction",
    }} {
        fmt.Printf("%s(10, 15) returned: %d\n", c.name, c.fn(10, 15))
        if c.gn != nil {
            c.gn(c.name)
        }
    }
}

My question is how to improve this code? What's the best way to achieve this in Go? Can I achieve a better solution using interface?

Use interfaces.

type Op interface {
	Name() string
	Do(a, b int) int
}

type Add struct{}

func (Add) Name() string    { return "add" }
func (Add) Do(a, b int) int { return a + b }

type Sub struct{}

func (Sub) Name() string    { return "sub" }
func (Sub) Do(a, b int) int { return a - b }

Playground: http://play.golang.org/p/LjJt6D0hNF.

EDIT: Since you've edited your question, here is an example of how you could use asserting and interface to a broader interface for your task:

type RevOp interface {
	Op
	ReverseDo(a, b int) int
}

// ...

func (Add) ReverseDo(a, b int) int { return a - b }

// ...

fmt.Printf("%s(10, 15) returned: %d\n", op.Name(), op.Do(10, 15))
if op, ok := op.(RevOp); ok {
	fmt.Printf("reverse of %s(10, 15) returned: %d\n", op.Name(), op.ReverseDo(10, 15))
}

Playground: http://play.golang.org/p/MQ6LlPDcEi.

I've discussed with some people in person and apparently my solution was correct. While it can be rewritten using interface, that's not necessarily an improvement.