Automatic propagation of monoidal mappend

Question

Let's say I have a monoid defined as this:

data TotalLine = TotalLine { totalQuantity :: Int, orderTotal :: Float }

instance Monoid TotalLine where
  mempty = zero
  mappend = add

As totalQuantity and orderTotal are both numbers they also form a monoid under (+) Is there any way to define

add :: TotalLine -> TotalLine -> TotalLine

so, Can I just propagate the mappend call on each field instead of having to manually define something like

add line1 line2 =
  TotalLine {
    totalQuantity = totalQuantity line1 + totalQuantity line2,
    orderTotal = orderTotal line1 + orderTotal line2
   }

score 7 · Answer 1 · answered Mar 18 '16 at 15:37

7

Note there are several monoids with domain Int (Nat, Float, ..) so I would find it highly confusing to read code that has instance Monoid Int. Then mappend could be any of plus, times, max, min, and a lot more.

answered Mar 18 '16 at 15:37

d8d0d65b3f7cf42

2,597
15
28

Minor note: I was confused at first by the parenthesis, since I misread it to imply that Nat,Float,... are distinct monoids with domain Int, which makes no sense. – chi Mar 18 '16 at 16:42

score 4 · Accepted Answer · edited May 23 '17 at 11:45

There's generic-deriving package matches exactly your requirement:

{-# LANGUAGE DeriveGeneric #-}

import           Generics.Deriving.Monoid
import           GHC.Generics

data T = T {str :: String, str' :: String}
  deriving (Generic, Show)

main = undefined

instance Monoid T where
  mempty = memptydefault
  mappend = mappenddefault

And some result from ghci:

> T "a" "b" `mappend` T "c" "d"
< T {str = "ac", str' = "bd"}

But it doesn't work out-of-box for your TotalLine data type, since both Int and Float do not have an instance of Monoid.

Also add a dependency just for that purpose is not so economic. You'd better implement the Monoid instance manually.

There has been some discussion on why GHC cannot derive Monoid instances, it turned out in general such derived instance may not be unique. ~~But in the special case when the data type have only one constructor with concrete and monoidal fields the derived instance is unique.~~

"but in the special case when the data type have only one constructor with concrete and monoidal fields the derived instance is unique." Although there is a *natural* monoid, it still isn't unique. It could `mappend` some of the fields in reverse order. — PyRulez, Mar 18 '16 at 17:01

score 3 · Answer 3 · answered Mar 18 '16 at 16:55

3

If you're fine changing the type a little (but that is still isomorphic to yours), you could try this:

{-# LANGUAGE GeneralizedNewtypeDeriving #-}
import Data.Monoid

newtype TotalLine = TotalLine (Sum Int, Sum Float) deriving Monoid

answered Mar 18 '16 at 16:55

PyRulez

10,513
10
42
87

Automatic propagation of monoidal mappend

3 Answers3