> these versions of the math operators don't quite work the same way as the > standard ones (e.g. `+` can throw), but they still carry math semantics
That is exactly what I argue should be avoided. When you see `+` you don’t expect it to throw. What’s more they don’t carry “math” semantics at all because for example Func * (Double, Measurement) -> Measurement is not even associative. I agree that operators for this kind of functions should exist and are the right syntactic tool. But I disagree with the current implementation. My proposition for the example of `*` is as follow: This signature happens quite often `(Number, T) -> T`. It would seem quite intuitive to have a dedicated operator for all “Scalar multiplication” which would be visually distinct from `*` (for example **, or Unicode ⊗) and consistent across codebases. For a + operator that throws, I would imagine a “TryAddable” protocol with a `+!` operator which can throw. I agree that it is visual noise, but I argue that it has tremendous value: consistant operator semantics. > (Also, I really doubt changing concatenation to `++` is going to fly. Swift > is not Haskell.) I doubt those remarks are very constructive. The point still stands: I find value in having different operators for different semantics. > On 1 Sep 2017, at 01:54, Brent Royal-Gordon <[email protected]> wrote: > >> On Aug 31, 2017, at 3:40 PM, André Videla via swift-evolution >> <[email protected]> wrote: >> >> Something I could imagine is deprecate operator overloading and constrain >> them to a single Type. For example, the operator `+` could be constrained to >> the protocol `Addable` and has the signature `infix func + (Self, Self) -> >> Self` and is commutative. Similarly, we could have a protocol `Concatenable` >> which has its own operator (e.g.: ++ ) and is not commutative. > > > These are basically "bag of syntax protocols" which aren't really usable > generically, so we don't want this design. And if you tied this to the > numeric protocols, then you couldn't use `+` for things that are numeric-ish > but don't quite fit the protocols. For instance, I have a library that adds > `+` and `*` operators to `Foundation.Measurement`; these versions of the math > operators don't quite work the same way as the standard ones (e.g. `+` can > throw), but they still carry math semantics and so `+` is the right operator > for them. If `+` was exclusively tied to a particular protocol with a > particular signature, I wouldn't be able to do that. > > (Also, I really doubt changing concatenation to `++` is going to fly. Swift > is not Haskell.) > > -- > Brent Royal-Gordon > Architechies >
_______________________________________________ swift-evolution mailing list [email protected] https://lists.swift.org/mailman/listinfo/swift-evolution
