This proposal is somewhat tongue in cheek, but at least it's amusing, and who knows, it might be good for something. The idea is that one could, in theory, allow both prefix unary minus and right sections of subtraction, with the type-checker deciding which is meant based on the context. Has this been noticed before? Consider the following code snippet, which runs in GHC 6.6 (with the new ability to define postfix operators).
{-# OPTIONS -fglasgow-exts -fallow-undecidable-instances -fallow-overlapping-instances #-} module Minus where import TypeCast
class Minus a b where (<->) :: a -> b
instance (Num a, TypeCast a b) => Minus a b where (<->) = typeCast . negate
instance (TypeCast a b, Num b, TypeCast b c) => Minus a (b -> c) where (<->) x y = typeCast ((typeCast x) - y)
(TypeCast is the usual one from HList etc.) Loading this in the interpreter, we now have: *Minus> (1 <->) :: Int -1 *Minus> 3 <-> 1 :: Int 2 *Minus> map (<-> 1) [2..5] [1,2,3,4] *Minus> map (1 <->) [2..5] [-1,-2,-3,-4] *Minus> map (<->) [2..5] :: [Int] [-2,-3,-4,-5] *Minus> zipWith (<->) [1,3,5] [1,2,3] [0,1,2] In short, the operator <-> can be used as *either* an infix subtraction operator (which can be sectioned on both sides) or a postfix unary negation operator (which can also be sectioned once). The trick is the same one used for variadic arguments: the type-checker can infer from context whether (1 <->) should return a number or a function, and resolves it accordingly. Thus, if we could figure out a way to define prefix operators, analogous to the way we can now define postfix operators, we could in theory allow prefix unary minus and right sections of subtraction to coexist peacefully. But I haven't had much luck coming up with a non-ugly suggestion for how to do this. I'd be interested to hear if anyone else has ideas, although I doubt any such solution would ever make it into any Haskell standard. (-: It's also unfortunate that we need the explicit type signatures in the interpreter above, but otherwise there would be no context for type-inference based on the return value. As usual, though, this problem would probably hardly ever arise in an actual program, where most values have a known type. (Actually, I still don't understand why a type signature is necessary on 3 <-> 1; anyone care to enlighten me?) Comments? Mike