Add `Enum` instance to `Down`, flipping direction

[gergoerdi]

This is an idea that was prompted by my surprise that this behaviour is not already the case...

The Bounded and Enum instances of Data.Ord.Down should be changed such that

succ @(Down a) = fmap pred

and all other methods implemented similarly.

Implementation is in MR !8242.

[konsumlamm]

I'm not sure what Down you're looking at, but for the one in base (https://hackage.haskell.org/package/base-4.16.1.0/docs/Data-Ord.html#t:Down) the Bounded instance already works like that and there currently is no Enum instance.

[tomjaguarpaw]

Bounded was derived in 4.14 but this has since been changed.

[gergoerdi]

Bounded was derived in 4.14 but this has since been changed.

Ah, that's good to know -- I was looking at 8.10.7, and didn't expect this has changed since.

[tomjaguarpaw]

Surprisingly I can't find where this was discussed, although I remember reading the discussion.

[gergoerdi]

there currently is no Enum instance.

Looking at it in detail, the problem is that while enumFrom* could be implement with some smarts, toEnum/fromEnum would be tricky. Would it be acceptable to only have Enum (Down a) if not only Enum a, but also Bounded a? Because then, we could have

    fromEnum (Down x) = fromEnum (maxBound @a) - fromEnum x
    toEnum k = Down $ toEnum $ fromEnum (maxBound @a) - k

[tomjaguarpaw]

not only Enum a, but also Bounded a

and also Num a? And also some fairly strong compatibility condition between them (that really ought to hold but I don't know if it actually holds for instances in practice).

[tomjaguarpaw]

I guess the compatibility condition is that pred == subtract 1 and succ == (+ 1) so maybe not that strong.

[gergoerdi]

not only Enum a, but also Bounded a

and also Num a? And also some fairly strong compatibility condition between them (that really ought to hold but I don't know if it actually holds for instances in practice).

No, the subtraction is done on the Int side.

[tomjaguarpaw]

Ah so it is. That looks nice then!

[andreasabel]

@gergoerdi : Can you please change the issue title to reflect the updates?

[gergoerdi]

So I guess the actual implementation would look something like this:

instance (Enum a, Bounded a) => Enum (Down a) where
    succ = fmap pred
    pred = fmap succ

    fromEnum (Down x) = fromEnum (maxBound @a) - fromEnum x
    toEnum k = Down $ toEnum $ fromEnum (maxBound @a) - k

    enumFrom (Down x) = Down <$> enumFromThen x (pred x)
    enumFromTo (Down x) (Down y) = Down <$> enumFromThenTo x (pred x) y

[andreasabel]

there currently is no Enum instance.

@gergoerdi : So would the title rather be: Add Enum instance for Down ?

[gergoerdi]

Another approach that doesn't even require Bounded a, just flips the direction of succ/pred via negating fromEnum. Unfortunately, we still can't avoid also defining enumFrom and enumFromThen to ensure proper stopping:

instance (Enum a) => Enum (Down a) where
    fromEnum = negate . fromEnum . getDown
    toEnum = Down . toEnum . negate

    enumFrom (Down x) = Down <$> enumFromThen x (pred x)
    enumFromThen (Down x) (Down y) = map Down $ enumFromThen x y

TBH I don't know how kosher this is, because of the whole negate @Int minBound == minBound situation, but other than that corner case, it should work fine.