Checklist

• I have searched the issue tracker for open issues that relate to the same feature, before opening a new one.
• This issue only relates to a single feature. I will open new issues for any other features.

Is your feature request related to a problem?

The binding (External)Untyped is used for external data structures to be bound and to be able to Set (and Reload) an external data structure you can not (in version 2.4.4) use "uncomparable" types in your (external) bound untyped data structure (such as slices).

The (External)Untyped is commonly used for user defined data types and it relies on the mechanisms of interface{} and reflection. To make the (External)Untyped even more usable I think it would benefit of the of use of a more comprehensive comparison operator than '==' that can handle a wider range of user defined data structures.

This fails:

type MyUncomparableStruct struct {
	ThisIsUncomparable []string
}

a := MyUncomparableStruct{[]string{"1", "2"}}
b := binding.BindUntyped(&a)
b.Reload()

Result:

panic: runtime error: comparing uncomparable type main.MyUncomparableStruct

Is it possible to construct a solution with the existing API?

No

Describe the solution you'd like to see.

I would like to see a more capable/competent value comparison for the (External)Untyped bindings as it is designed to work with user defined structures/data models.

Change the comparison in binding.go:Set from '==' to either go-cmp.Equal or reflect.DeepEqual.

Thoughts of consideration:
Both comparison implementation comments (for Equal and DeepEqual) warn about the inefficiency, compared to '=='.
However you can argue that reflection is already used for (external) untyped.
you can also argue that the go efficiency considerations might not have been raised with UI interfaces in mind but rather data crunching under high load.
And if humongous amount of data is to be displayed or handled then the program would probably benefit from a more efficiently data type specifically deviced for the UI rather than a "complex" program data model type in the first place.

A slightly related issue:
#2908

Comment annotated excerpt from binding.go:

func (b *boundExternalUntyped) Set(val interface{}) error {
	b.lock.Lock()
	defer b.lock.Unlock()
	if b.old == val { // <--- This is the comparison that fails if you try to compare bound data that contain "uncomparable" fields.
		return nil
	}
	b.val.Set(reflect.ValueOf(val))
	b.old = val

	b.trigger()
	return nil
}

func (b *boundExternalUntyped) Reload() error {
	return b.Set(b.val.Interface())
}

Equal and DeepEqual that handle comparison of 'uncomparable' types:

type MyUncomparableStruct struct {
	ThisIsUncomparable []string
}

var a interface{}
var b interface{}
a = MyUncomparableStruct{[]string{"1", "2"}}
b = MyUncomparableStruct{[]string{"1", "2"}}

if reflect.DeepEqual(a, b) {
	fmt.Println("Equality for all! (Using DeepEqual)")
}

if cmp.Equal(a, b) {
	fmt.Println("Equality for all! (Using Equal)")
}

if a == b {
	fmt.Println("Equality for all! (Using ==)")
}

Result:

Equality for all! (Using DeepEqual)
Equality for all! (Using Equal)
panic: runtime error: comparing uncomparable type main.MyUncomparableStruct