Function pointer as argument with "return interface{}"

Question

I would like to pass a function pointer to a function to "anything".

It's easy to print something that gets passed in from just about anything (as in https://play.golang.org/p/gmOy6JWxGm0):

func printStuff(stuff interface{}) {
    fmt.Printf("Testing : %v", stuff)
}

Let's say, though, that I want to do this:

1. Have multiple structs
2. Have data loaded from various functions
3. Have a generic print that calls the function for me

I tried this in a Play (https://play.golang.org/p/l3-OkL6tsMW) and I get the following errors:

./prog.go:35:12: cannot use getStuff1 (type func() SomeObject) as type FuncType in argument to printStuff

./prog.go:36:12: cannot use getStuff2 (type func() SomeOtherObject) as type FuncType in argument to printStuff

In case the Play stuff gets deleted, here's the code I'm trying to figure out how to get to work:

package main

import (
    "fmt"
)

type SomeObject struct {
    Value string
}

type SomeOtherObject struct {
        Value string
}

type FuncType func() interface{}

func getStuff1() SomeObject {
    return SomeObject{
        Value: "Hello, world!",
    }
}

func getStuff2() SomeOtherObject {
    return SomeOtherObject{
        Value: "Another, hello!",
    }
}

func printStuff(toCall FuncType) {
    stuff := toCall()
    fmt.Printf("Testing : %v", stuff)
}

func main() {
    printStuff(getStuff1)
    printStuff(getStuff2)
}

What is the secret sauce to get this stuff passed in properly?

Larger Goal Explanation

So what I am trying to accomplish here is reduction of boilerplate code that lives inside a gigantic file. Unfortunately I cannot refactor it further at this point due to other restrictions and I was wondering if this were possible at all considering the error messages and what I had read seemed to dictate otherwise.

There's a large amount of copy-and-paste code that looks like this:

func resendContraDevice(trap *TrapLapse, operation *TrapOperation) {
    loaded := contra.Load()
    err := trap.SnapBack(operation).send(loaded);

    // default error handling
    // logging
    // boilerplate post-process
}

func resendPolicyDevice(trap *TrapLapse, operation *TrapOperation) {
    loaded := policy.Load()
    err := trap.SnapBack(operation).send(loaded);

    // default error handling
    // logging
    // boilerplate post-process
}

// etc.

In these, the Load() functions all return a different struct type and they are used elsewhere throughout the application.

I want hoping to get something where I could have:

loaded := fn()
err := trap.SnapBack(operation).send(loaded);

// default error handling
// logging
// boilerplate post-process

Signature for send is, which accepts an interface{} argument:

func (s SnapBack) send(data interface{}) error

Answer 1

I don't know if you have control over the return values of contra.Load() and policy.Load(), for instance, so there may be a better approach, but assuming those cannot be modified, this would allow you to eliminate a lot of boilerplate, without any fancy manipulation:

func boilerplate(tram *TrapLapse, operation *TrapOperation, loader func() interface{}) {
    loaded := loader()
    err := trap.SnapBack(operation).send(loaded);

    // default error handling
    // logging
    // boilerplate post-process
}

func resendContraDevice(trap *TrapLapse, operation *TrapOperation) {
    boilerplate(trap, operation, func() interface{} { return contra.Load() })
}

func resendPolicyDevice(trap *TrapLapse, operation *TrapOperation) {
    boilerplate(trap, operation, func() interface{} { return policy.Load() })
}

If there's nothing more complex, you can also simplify this even further:

func boilerplate(tram *TrapLapse, operation *TrapOperation, loaded interface{}) {
    err := trap.SnapBack(operation).send(loaded);

    // default error handling
    // logging
    // boilerplate post-process
}

func resendContraDevice(trap *TrapLapse, operation *TrapOperation) {
    boilerplate(trap, operation, contra.Load())
}

func resendPolicyDevice(trap *TrapLapse, operation *TrapOperation) {
    boilerplate(trap, operation, policy.Load())
}