I thought of a way to do something similar to the “implements” proposal without
introducing operator overloading: turn it around. Instead of letting methods
implement operators, we could let operators implement methods.
type Lesser(type T) interface {
Less(b T) bool for(<)
}
This interface would be implemented by any type that has an appropriate Less
method, and by any type that works with the < operator. For example int would
implement Lesser(int).
It would be nice if we could get rid of the type parameter. One way would be to
adopt the Self type from Rust:
type Lesser interface {
Less(b Self) bool for (<)
}
For types implementing the interface, Self would be replaced by the
implementing type:
type vehicle struct {
weight float64
horsepower float64
}
func (v vehicle) Less(b vehicle) bool {
return v.weight < b.weight
}
For code using the interface, Self would be replaced by the interface type; it
would be as though Lesser had been declared as
type Lesser interface {
Less(b Lesser) bool
}
But if a mis-matched type was passed to Less, it would need to panic. So this
option (using the Self type) would somewhat reduce compile-time type safety.
Andy
--
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.
For more options, visit https://groups.google.com/d/optout.
