[Haskell-beginners] Fwd: Averaging a string of numbers

[Dean Herington]

At 9:04 PM +1000 12/12/11, Ben Kolera wrote:
>There is some magic here that I'm not quite groking. Sorry for my
>slowness; but I seem to be missing a step:

Oops, my bad!  The magic is an inadequate test ;-).  Thanks for 
spotting the bug!

The magic I was trying to leverage is this instance from Data.Monoid:

instance Monoid a => Monoid (Maybe a) where
   mempty = Nothing
   Nothing `mappend` m = m
   m `mappend` Nothing = m
   Just m1 `mappend` Just m2 = Just (m1 `mappend` m2)

I've implemented it correctly (I hope) for `Minimum` in my revised 
code below.  But the usability suffers with that approach.  Better, I 
think, is to keep the original interface and implement it correctly 
(as I hope to have done for `Maximum`).  You'll note that it 
incorporates essentially your original `chooseMaybe` function.

>
>This is how I'd expect liftA2 to work ( and is why I didn't use lift
>in my initial response ):
>
>*Main Control.Applicative Data.Monoid> liftA2 max Nothing (Just 1)
>Nothing
>
>I expected all the magic to be the applicative class instance that was
>generated for Maximum by the GeneralizedNewtypeDeriving extension, but
>why do these not work?
>
>*Main Control.Applicative Data.Monoid> liftA2 max (Maximum Nothing)
>(Maximum (Just 1))
>Maximum {getMaximum = Nothing}
>*Main Control.Applicative Data.Monoid> mempty `mappend` (Maximum (Just
>1)) `mappend` (Maximum (Just 2) )
>Maximum {getMaximum = Nothing}
>
>When this obviously works just fine?
>
>*Main Control.Applicative Data.Monoid> main
>Stats {ct = Sum {getSum = 0}, sm = Sum {getSum = 0.0}, mn = Minimum
>{getMinimum = Nothing}, mx = Maximum {getMaximum = Nothing}}
>Stats {ct = Sum {getSum = 1}, sm = Sum {getSum = 1.0}, mn = Minimum
>{getMinimum = Just 1.0}, mx = Maximum {getMaximum = Just 1.0}}
>Stats {ct = Sum {getSum = 1}, sm = Sum {getSum = 2.0}, mn = Minimum
>{getMinimum = Just 2.0}, mx = Maximum {getMaximum = Just 2.0}}
>Stats {ct = Sum {getSum = 2}, sm = Sum {getSum = 3.0}, mn = Minimum
>{getMinimum = Just 1.0}, mx = Maximum {getMaximum = Just 2.0}}
>
>
>Sorry if I am missing something obvious and this question is really silly!
>
>On Mon, Dec 12, 2011 at 5:18 PM, Dean Herington & Elizabeth Lacey
><heringtonlacey at mindspring.com> wrote:
>>  At 8:21 AM +1000 12/12/11, Ben Kolera wrote:
>>>
>>>  That is just because you are calling min and max against the Maybe
>>>  rather than on the values inside of your maybes. Max is working
>>>  because there is an instance of Ord for Maybe and
>>>
>>>  Nothing > Just n > Just ( n + 1 )
>>
>>
>>  You have the right idea, but replace `>` above by `<`.
>>
>>
>>>
>>>  This is certainly not the most elegant solution ( I am a beginner, too
>>>  ) but here is what I would do:
>>>
>>>  instance Monoid Stats where
>>>   mempty  = Stats 0 Nothing Nothing 0
>>>   mappend (Stats sm1 mn1 mx1 len1) (Stats sm2 mn2 mx2 len2) =
>>>    Stats
>>>    (sm1 + sm2)
>>>    (chooseMaybe min mn1 mn2)
>>>    (chooseMaybe max mx1 mx2)
>>>    (len1 + len2)
>>>
>>>  chooseMaybe _ Nothing Nothing   = Nothing
>  >> chooseMaybe _ (Just a) Nothing  = Just a
>>>  chooseMaybe _ Nothing  (Just b) = Just b
>>>  chooseMaybe f (Just a) (Just b) = Just $ f a b
>>>
>>>
>>>  Hopefully this quick answer can get you on your way to solving your
>>>  problem and we can both learn a better way of doing it when someone
>>>  optimises my solution. ;)
>>
>>
>>  You've got the principle just right.  Here's a way to cast it that makes it
>>  apparent that `Stats` is a monoid in a "componentwise" fashion.
>>
>>
>>  {-# LANGUAGE GeneralizedNewtypeDeriving #-}
>>
>>  import Data.Monoid
>>  import Control.Applicative
>>
>>
>>  -- | Monoid under minimum.
>>  newtype Minimum a = Minimum { getMinimum :: Maybe a }
>>     deriving (Eq, Ord, Functor, Applicative, Read, Show)
>>
>>  instance Ord a => Monoid (Minimum a) where
>>     mempty  = Minimum Nothing
>>     mappend = liftA2 min
>>
>>  -- | Monoid under maximum.
>>  newtype Maximum a = Maximum { getMaximum :: Maybe a }
>>     deriving (Eq, Ord, Functor, Applicative, Read, Show)
>  >
>>  instance Ord a => Monoid (Maximum a) where
>>     mempty  = Maximum Nothing
>>     mappend = liftA2 max
>>
>>  data Stats = Stats {
>>       ct :: Sum Int,
>>       sm :: Sum Double,
>>       mn :: Minimum Double,
>>       mx :: Maximum Double }
>>     deriving (Eq, Show, Read)
>>
>>  instance Monoid Stats where
>>     mempty = Stats mempty mempty mempty mempty
>>     mappend (Stats ct1 sm1 mn1 mx1) (Stats ct2 sm2 mn2 mx2) =
>>         Stats (ct1 `mappend` ct2)
>>               (sm1 `mappend` sm2)
>>               (mn1 `mappend` mn2)
>>               (mx1 `mappend` mx2)
>>
>>
>>  mkStats v = Stats (Sum 1) (Sum v) (Minimum (Just v)) (Maximum (Just v))
>>
>>  st0, st1, st2, st3 :: Stats
>>
>>  st0 = mempty
>>  st1 = mkStats 1
>>  st2 = mkStats 2
>>  st3 = st1 `mappend` st2
>>
>>  main = mapM_ print [st0, st1, st2, st3]


{-# LANGUAGE GeneralizedNewtypeDeriving #-}

import Data.Monoid
import Control.Applicative
import Control.Monad


-- The approach taken for `Minimum` is for illustration.
-- The approach taken for `Maximum` is recommended for its better usability.

-- | Monoid under minimum.
newtype Minimum a = Minimum { getMinimum :: a }
     deriving (Eq, Ord, Read, Show)

instance Ord a => Monoid (Minimum a) where
     mempty = error "There is no minimum of an empty set."
     Minimum x `mappend` Minimum y = Minimum (x `min` y)

-- | Monoid under maximum.
newtype Maximum a = Maximum { getMaximum :: Maybe a }
     deriving (Eq, Ord, Functor, Applicative, Read, Show)

instance Ord a => Monoid (Maximum a) where
     mempty = Maximum Nothing
     Maximum (Just x) `mappend` Maximum (Just y) = Maximum $ Just (x `max` y)
     Maximum x        `mappend` Maximum y        = Maximum $       x `mplus` y


data Stats = Stats {
       ct :: Sum Int,
       sm :: Sum Double,
       mn :: Maybe (Minimum Double),
       mx :: Maximum Double }
     deriving (Eq, Show, Read)

instance Monoid Stats where
     mempty = Stats mempty mempty mempty mempty
     mappend (Stats ct1 sm1 mn1 mx1) (Stats ct2 sm2 mn2 mx2) =
         Stats (ct1 `mappend` ct2)
               (sm1 `mappend` sm2)
               (mn1 `mappend` mn2)
               (mx1 `mappend` mx2)


mkStats v = Stats (Sum 1) (Sum v) (Just (Minimum v)) (Maximum (Just v))

st0, st1, st2, st3 :: Stats

st0 = mempty
st1 = mkStats 1
st2 = mkStats 2
st3 = st1 `mappend` st2
st4 = st0 `mappend` st1

main = mapM_ print [st0, st1, st2, st3, st4]