Arithmetic for values inside a maybe, inside a record or How to write the instance for (Num (Maybe a)) - haskell

Question

Given I have the following:
data Tick = Tick { _price :: Int } deriving (Eq, Ord)
type High = Maybe Tick
type Low = Maybe Tick
data Candle = Candle
{ _open :: Open
, _high :: High
, _low :: Low
, _close :: Close
} deriving (Eq, Ord)
makeLenses ''Candle
When I create a Candle:
candle = ...
Then I wish to use the calculate the difference between high and low:
axis = high - low
Results in:
• No instance for (Num High) arising from a use of ‘-’
• In the expression: high - low
In an equation for ‘axis’: axis = high - low
I have tried creating an instance like this:
instance Num High where
(-) (Just a) (Just b) = Just (a - b)
But that results in the error:
• Illegal instance declaration for ‘Num High’
(All instance types must be of the form (T t1 ... tn)
where T is not a synonym.
Use TypeSynonymInstances if you want to disable this.)
• In the instance declaration for ‘Num High’
So my question is, what should the instance for (Num High) look like to allow my calculation?

Answer 1

Arghhhh... no! Don't do that! Why do you think this is a good idea?
High is not a number type, because it also contains the non-number value Nothing☆. (Even any such reasoning aside, it's basically never a good idea to define an instance for a type and class that are both in an established standard library, most certainly not base. Such an instance will surprise everybody who knows these libraries and suddenly runs into unexpected instances! Also, if the instance did make sense, the GHC people would probably have already defined it.)
What the Maybe does is, it forces you to think about the case where there is no number, i.e. where either upper or lower boundary aren't given. I don't know what behaviour you want for this case, but plausible would be to immediately make the axis-result Nothing too then. This is readily accomplished using Maybe's Applicative instance:
axis :: Maybe Int
axis = (-) <$> candle^.high <*> candle^.low
...provided that Tick itself has a Num instance, which might not be very prudent either† but at least plausible. If it doesn't have a Num instance, you need to unwrap the Tick constructor:
axis = Tick <$> ((-) <$> (_price <$> candle^.high) <*> (_price <$> candle^.low)
That said, if you insist to define that instance (as you shouldn't), then it's easy enough to do. For one thing, you could just unravel the type synonym:
instance Num (Maybe Tick) where
Just (Tick a) - Just (Tick b) = Just . Tick $ a - b
_ - _ = Nothing
But that's not even necessary; as the compiler already hinted you can directly give instances via type synonyms, it's just not Haskell98. Just enable the extension
{-# LANGUAGE TypeSynonymInstances #-}
or
{-# LANGUAGE FlexibleInstances #-}
and then
instance Num High where
...
is accepted, for better or for worse.
&star;
Note that just using Applicative for defining a Num instance leads to trouble: you want - and + to be cancellative, i.e. (a - b) + b ≡ a. But with the straightforward a+b = (+)<$>a<*>b (which can also be written (+)=liftA2(+)) you would have
(Just 1 - Nothing) + Nothing = Nothing
‡ Just 1
...mind, much the same behaviour is already exhibited by the floating-point instances
Prelude> (1 - 1/0) + 1/0
NaN
but at least there it's understood that infinities and NaN are corner cases where everything gets a bit weird, whereas for a Maybe Int you'd expect the Nothing to be a pretty normal, “it's just not here” value.
†
A better instance is probably
import Data.AdditiveGroup
instance AdditiveGroup Tick
...which works without any explicit implementation, provided you add Generic to the data definition:
{-# LANGUAGE DeriveGeneric #-}
import GHC.Generics
data Tick = Tick { _price :: Int } deriving (Eq, Ord)
With that defined, you can then do
axis = (^-^) <$> candle^.high <*> candle^.low