I was thinking about a way to "extend" usual operations (say, equality
checks) to types that can not be compared the usual way (they are not
"comparable" in the contract sense) and came up with something like this:
// Just to use for type assertion later.
type Equaler interface {
Equal(Equaler) bool
}
contract Comparable(T) {
T comparable(T), Equal(T) bool
}
func Compare(type T Comparable)(a, b T) bool {
if eq, ok := a.(Equaler); ok {
return eq.Equal(b)
}
return a == b // Does this work at all?
}
Would this work? More specifically it looks to me that that if the specific
type is not comparable (But has the Equal method), the compiler might see
the "==" comparison in the function and give an error.
One way around this would possibly be to use something similar to type
assertion (in this case, a and b would have to be asserted to "comparable"
which I guess is not possible as it is a contract). Or, the compiler could
be smart enough to know that if we reached that check, then the type must
be comparable (so it would also not give an error).
--
You received this message because you are subscribed to the Google Groups
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to golang-nuts+unsubscr...@googlegroups.com.
To view this discussion on the web visit
https://groups.google.com/d/msgid/golang-nuts/CAEd86TxWSc4VajyWj0J2quMP4uJC095Z1uZced4aiuV4e8St7g%40mail.gmail.com.
