This can be simplified quite a bit. The Interface() method on reflect.Value allows you to access the value as a regular go interface.

We also need to handle the case where the value is already a pointer to the implementation of TextUnmarshaled. I would handle this by accepting a shouldAddr argument.

My implementation of this would probably look something like:

func unmarshalText(t reflect.Type, v reflect.Value, s string, shouldAddr bool) error {
	if shouldAddr {
		v = v.Addr()
	}
	if t.Kind() == reflect.Ptr && v.IsNil() {
		v.Set(reflect.New(t.Elem()))
	}
	return v.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(s))
}

I will definitely change the much simpler method invocation, thanks!

I didn't add support for pointers on purpose as all the other types don't support pointers yet. I thought this could be addressed in a new issue and possibly implemented using a more dynamic / recursive approach for all supported types.

What do you think? Should I add pointer support already or not?

Hmmmmmm, Good point.

I think I would go ahead and add pointer support for TextUnmarshaler. It starts to get confusing what is and isn't supported when you don't allow pointers for interface types.

✔️

I also added tests for empty non-required parameters and added another example to the readme.

I would move all of the logic for TextUnmarshaler into the setValue function.

We also need to handle the case where the value is already a pointer to the implementation of TextUnmarshaled.

Something like:

func setValue(v reflect.Value, s string) error {
	t := v.Type()

	if t.Implements(textUnmarshalerType) {
		return unmarshalText(t, v, s, /*shouldAddr*/ false)
	}
	if reflect.PtrTo(t).Implements(textUnmarshalerType) {
		return unmarshalText(t, v, s, /*shouldAddr*/ true)
	}
	
	//...
}