monoids

I tried to write a generalized maximum function similar to the one in Prelude . My first naiv approach looked like this: maximum' :: (F.Foldable a, Ord b) => a b -> Maybe b maximum' mempty = Nothing maximum' xs = Just $ F.foldl1 max xs However, when I test it it always returns Nothing regardless of the input: > maximum' [1,2,3] > Nothing Now I wonder whether it's possible to obtain the empty value of a Monoid type instance. A test function I wrote works correctly: getMempty :: (Monoid a) => a -> a getMempty _ = mempty > getMempty [1,2,3] > [] I had already a look at these two questions but I

Today I tried to reduce a list of functions trough monoid typeclass but the resulting function expects its argument to be an instance of Monoid for some reason. GHCI tells me that the type of mconcat [id, id, id, id] is Monoid a => a -> a . Yet I would expect it to be a -> a . What is happening? You're using this instance: instance Monoid b => Monoid (a -> b) where mempty _ = mempty mappend f g x = f x `mappend` g x which is more general because it doesn't require endomorphisms (i.e. a -> a ). To get the instance you were expecting, you can wrap your functions in Endo : appEndo (mconcat [Endo

I read Why MonadPlus and not Monad + Monoid? and I understand a theoretical difference, but I cannot figure out a practical difference, because for List it looks the same. mappend [1] [2] == [1] <|> [2] Yes. Maybe has different implementations mappend (Just "a") (Just "b") /= (Just "a") <|> (Just "b") But we can implement Maybe Monoid in the same way as Alternative instance Monoid (Maybe a) where Nothing `mappend` m = m m `mappend` _ = m So, can someone show the code example which explains a practical difference between Alternative and Monoid? The question is not a duplicate of Why MonadPlus

I've been going through Haskell monoids and their uses , which has given me a fairly good understanding of the basics of monoids. One of the things introduced in the blog post is the Any monoid, and it's usage like the following: foldMap (Any . (== 1)) tree foldMap (All . (> 1)) [1,2,3] In a similar vein, I've been trying to construct a Maximum monoid and have come up with the following: newtype Maximum a = Maximum { getMaximum :: Maybe a } deriving (Eq, Ord, Read, Show) instance Ord a => Monoid (Maximum a) where mempty = Maximum Nothing m@(Maximum (Just x)) `mappend` Maximum Nothing = m

GHC has a few language flags, such as DeriveFunctor , DeriveDataTypeable etc., which enable compiler generation of derived instances for type classes other than those allowed in Haskell 98. This especially makes sense for something like Functor , where the laws of that class dictate an obvious, "natural" derived instance. So why not for Monoid ? It seems like for any data type with a single data constructor: data T = MkT a b c ... one could mechanically produce a Monoid instance (excuse the pseudocode): instance (Monoid a, Monoid b, Monoid c, ...) => Monoid T where mempty = MkT mempty mempty