How to make gqlgen dataloader Loader.Load(key) return a function that returns an explicit data type instead of interface{}?

I want to use graph-gophers/dataloader to implement a dataloader for bulk-fetching users.

I have implemented it like below but I need to return an explicit data type, not an interface{}

Firstly, I create UserReader with function GetUsers by given dataloader.Keys:

type UserReader struct {
	userCtrl user.Controller // This is my user service for Create, Get, Delete user
}

func newUserReader(userCtrl user.Controller) UserReader {
	return UserReader{
		userCtrl: userCtrl,
	}
}

// GetUsers return a list of result by given keys
func (reader UserReader) GetUsers(ctx context.Context, keys dataloader.Keys) []*dataloader.Result {
	output := make([]*dataloader.Result, len(keys))
	for i, key := range keys {
		userID := key.String()
        
        // Get list of user by string userID
		result, err := reader.userCtrl.GetUsers(ctx, userID)
		output[i] = &dataloader.Result{Data: result, Error: err}
	}

	return output
}

And then, I create a Loader with function GetUser to get a user by userID, it won't request data from userCtrl more than 1 time in a single request.

type Loader struct {
	userLoader *dataloader.Loader
}

func newLoader(userCtrl user.Controller) Loader {
	userReader := newUserReader(userCtrl)
	return Loader{
        // Create new user loader with batch function
		userLoader: dataloader.NewBatchedLoader(userReader.GetUsers),
	}
}

// UserLoader returns the user loader
func (loader Loader) UserLoader() *dataloader.Loader {
	return loader.userLoader
}

// GetUser return a user by given parameter
func (loader impl) GetUser(ctx context.Context, userID string) (model.User, error) {
	// FromCtx gets a Loader from context if it exists, else nil.
    ctxLoader := FromCtx(ctx)
    
    // Thunk is function return value with interface{} type and error
	thunk := ctxLoader.UserLoader().Load(ctx, dataloader.StringKey(userID))
	result, err := thunk()
	if err != nil {
		return nil, err
	}
	return result.(model.User), nil // Convert datatype here!!!
}

And finally, It can be use

dataloader.FromCtx(ctx).GetUser(ctx, userID)

But I need userReader.getUsers to return an object containing model.user not interface{} because I don't want to convert the data type in the Loader.getUser function.

Is there a way to have dataloader.Result return a certain data type instead of the interface{}?

The v7 version of graph-gophers/dataloader supports generics. Specifically, the BatchFunc signature has changed so you can specify the resulting type.