hunk.code_window: func (s *RedisSupplier) RoleDelete(ctx context.Context, roleId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
   	result := s.Next().RoleGet(ctx, roleId, hints...)
   	if result.Err == nil {
   		role := result.Data.(*model.Role)
   		key := buildRedisKeyForRoleName(role.Name)
  
hunk.labels: keep keep keep keep keep replace replace keep
hunk.after_edit: 		defer func() {
   			role := result.Data.(*model.Role)
   			key := buildRedisKeyForRoleName(role.Name)
  
hunk.file_path: store/redis_supplier_roles.go
hunk.type: replace
file: package mapstructure
  
  import (
  	"errors"
  	"fmt"
  	"sort"
  	"strings"
  )
  
  // Error implements the error interface and can represents multiple
  // errors that occur in the course of a single decode.
  type Error struct {
  	Errors []string
  }
  
  func (e *Error) Error() string {
  	points := make([]string, len(e.Errors))
  	for i, err := range e.Errors {
  		points[i] = fmt.Sprintf("* %s", err)
  	}
  
  	sort.Strings(points)
  	return fmt.Sprintf(
  		"%d error(s) decoding:\n\n%s",
  		len(e.Errors), strings.Join(points, "\n"))
  }
  
  // WrappedErrors implements the errwrap.Wrapper interface to make this
  // return value more useful with the errwrap and go-multierror libraries.
  func (e *Error) WrappedErrors() []error {
  	if e == nil {
  		return nil
  	}
  
  	result := make([]error, len(e.Errors))
  	for i, e := range e.Errors {
  		result[i] = errors.New(e)
  	}
  
  	return result
  }
  
  func appendErrors(errors []string, err error) []string {
  	switch e := err.(type) {
  	case *Error:
  		return append(errors, e.Errors...)
  	default:
  		return append(errors, e.Error())
  	}
  }
  