How can I assign a reflect.Value that holds an error object to an ordinary variable of type error?

I am trying to write a function that returns back to its caller an error result taken from the result slice of reflect.ValueOf(somefunc).Call(someargs).

I've tried numerous variants of refer. calls, and type assertions. but cannot seem to get the compiler to let me put the actual concrete value from the reflect.Value slice back into an ordinary error variable.

Here's the code, using os.Getwd as the function:

   var somefunc interface{}
   var errToCaller *error
   somefunc = os.Getwd
   ftype := reflect.TypeOf(somefunc)
   errType := reflect.TypeOf(errToCaller).Elem()
   resType := ftype.Out(1)
   fmt.Println("resType.Implements(errType) = ",
      resType.Implements(errType))
   res := reflect.ValueOf(somefunc).Call([]reflect.Value{})
   fmt.Printf("res[1] as %%v = %v\n", res[1])
   fmt.Printf("res[1] as %%#v = %#v\n", res[1])
   fmt.Printf("ValueOf(res[1]) as %%v = %v\n",
      reflect.ValueOf(res[1]))
   fmt.Printf("ValueOf(res[1]) as %%#v = %#v\n",
      reflect.ValueOf(res[1]))
   fmt.Printf("ValueOf(res[1]).Type() as %%#v = %#v\n",
      reflect.ValueOf(res[1]).Type())
   fmt.Printf("ValueOf(res[1]).Interface() as %%#v = %#v\n",
      reflect.ValueOf(res[1]).Interface())
   // *errToCaller = reflect.ValueOf(res[1])
   // *errToCaller = reflect.ValueOf(res[1]).Interface()
   // *errToCaller = reflect.ValueOf(res[1]).Interface().(error)

With the following output:

resType.Implements(errType) =  true
res[1] as %v = <nil>
res[1] as %#v = error(nil)
ValueOf(res[1]) as %v = <error Value>
ValueOf(res[1]) as %#v = reflect.Value{typ:(*reflect.rtype)(0x4b9a60), ptr:(unsafe.Pointer)(0xc42000a3f0), flag:0x94}
ValueOf(res[1]).Type() as %#v = &reflect.rtype{size:0x18, ptrdata:0x10, hash:0x500c1abc, tflag:0x7, align:0x8, fieldAlign:0x8, kind:0x19, alg:(*reflect.typeAlg)(0x4a62d0), gcdata:(*uint8)(0x4daa41), str:21371, ptrToThis:184032}
ValueOf(res[1]).Interface() as %#v = error(nil)

I've abbreviated the example to remove lots of other Printf statements that indicate (to me at least) that the types are the same (even in what I think are the relevant fields of the reflect.Value struct). Why, when all of the various print statements seem to be telling me the result is an error value, can't I assign it to my local variable?

Uncommenting the first assignment in the code example above results in this complaint from the compiler:

./passerror.go:30: cannot use reflect.ValueOf(res[1]) (type reflect.Value) as type error in assignment:
        reflect.Value does not implement error (missing Error method)

So I figured I needed the Interface() result, but still no luck (using the 2nd assignment commented out above):

./passerror.go:31: cannot use reflect.ValueOf(res[1]).Interface() (type interface {}) as type error in assignment:
        interface {} does not implement error (missing Error method)

Finally, a type assertion on the Interface() return value causes a panic:

panic: interface conversion: reflect.Value is not error: missing method Error

No matter what I've tried, I can't seem to escape from the dreaded reflect.Value which prevents me from doing the assignment to ordinary error variable. I have tried Set() also without success, but perhaps incorrectly.

I would be forever grateful for insight and/or the magic incantation to do this.