code: func typesMaybeCompatible(dest reflect.Type, src reflect.Type) bool {
  	// The same types are obviously compatible.
  	if dest == src {
  		return true
  	}
  
  	// When both types are numeric, they are potentially compatible.
  	srcKind := src.Kind()
  	destKind := dest.Kind()
  	if isNumeric(destKind) && isNumeric(srcKind) {
  		return true
  	}
  
  	if srcKind == reflect.String {
  		// Strings can potentially be converted to numeric types.
  		if isNumeric(destKind) {
  			return true
  		}
  
  		switch destKind {
  		// Strings can potentially be converted to bools by
  		// strconv.ParseBool.
  		case reflect.Bool:
  			return true
  
  		// Strings can be converted to any other type which has as
  		// underlying type of string.
  		case reflect.String:
  			return true
  
  		// Strings can potentially be converted to arrays, slice,
  		// structs, and maps via json.Unmarshal.
  		case reflect.Array, reflect.Slice, reflect.Struct, reflect.Map:
  			return true
  		}
  	}
  
  	return false
  }
docs: // typesMaybeCompatible returns whether the source type can possibly be
  // assigned to the destination type.  This is intended as a relatively quick
  // check to weed out obviously invalid conversions.