Quoting Eric Raymond (2018-10-16 13:41:47) > On Tuesday, October 16, 2018 at 1:23:20 PM UTC-4, Dave MacFarlane > wrote: > > [...] > > Would there be any rules defined for relationships between > operators? > For instance, if the "<" operator is defined does "<=" come for free > or does it require a separate overloading? (If so, what about ">"?) >
> Good� heavens, no - < doesn't imply a definition of >.� That kind of > spooky side effect would be extremely un-Go-like. The alternative though is having to implement several different methods with obvious implementations in terms of one another, and make sure they're consistent. IMO this is worse than `x > y` desugaring to `y < x`, which at least you can't screw up. `==` is fiddly here, since you want to be able to define it without implementing `<`, but if you have `<` (and we assume it is a total order), it fully determines what `==` should do. > Besides, you don't want it. There are lots of uses for partial > orderings. The partial vs. total order thing brings up another issue that I think needs to be kept in mind: what are the contracts for the various operators? Right now we don't have to be too explicit about what +, *, <, == etc. mean in general, because we have a fixed finite number of them, so we don't have to have a general meaning. If we allow overloading e.g. `<`, we need to be clear on whether it's a partial or total order. I actually think we should require a total order, as all of the existing implementations are total orders (except floats, which violate every rule you might want to believe about numbers...), total orders are likely to be the norm, and I would expect a partial order to catch someone off guard. Most of the existing examples assume a total order. Similar issues come up with the arithmetic operators. For example, must `*` be commutative? If so, then matrix multiplication should not use `*`. Also, right now we have `+` defined on both numbers and strings. What does this operator mean in the general sense? The most specific things I can identify to say about it is that: 1. It is associative. 2. The zero value is an identity on both sides. This is called a Monoid in abstract algebra. It is far from useless; for example, it's exactly the structure you want for map-reduce (though that would be horribly inefficient on strings). But it's also super abstract, and I think not the sort of interface we should have on built-ins in Go. I think there are solutions to all of these things, but they require careful consideration. Importantly, we have to figure out where and how we're going to document these rules so that people actually see and understand them. It's not enough for us to have a thing buried in the spec that `*` should be commutative; the author of that matrix library has to see it. -Ian -- 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.
