Reexport Ap and change definition of foldMapA to use Ap

[chessai]

current definition of foldMapA:

foldMapA :: forall b m f a . (Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b
foldMapA f = foldr (\a mb -> liftA2 mappend (f a) mb) (pure mempty)

instead of using an explicit right fold, it might be better to use whatever foldMap is, using Data.Monoid.Ap:

newtype Ap f a = Ap { getAp :: f a }
  deriving (Functor, Applicative)

instance (Applicative f, Semigroup a) => Semigroup (Ap f a) where
  x <> y = liftA2 (<>) x y

instance (Applicative f, Monoid a) => Monoid (Ap f a) where
  mempty = pure mempty

foldMapA :: (Monoid b, Foldable t, Applicative f) => (a -> f b) -> t a -> f b
foldMapA f = getAp . foldMap (Ap . f)

definitions of foldMap are usually defined to be advantageous over the structure of a particular Foldable; using foldr is picking the direction of association, which seems unnecessary.

[chessai]

this also applies to foldMapM

[cronokirby]

This is seems like a great idea to me!

[chessai]

note that i believe base 4.13 is going to have foldMap', a strict variant of foldMap, so something like foldMapA' can just be defined in terms of this new function.

[chshersh]

@chessai This looks like a good improvement! Unfortunately, Ap was introduced in base-4.12 (GHC-8.6.1) and relude supports all GHC versions to GHC-8.0.2. so the only possible way to implement foldMapA in this version is to use -XCPP and have two function with same types but different solutions.

• http://hackage.haskell.org/package/base-4.12.0.0/docs/Data-Monoid.html#t:Ap

[chessai]

Yeah. We could also define it for this purpose and not export it. What i typed out wrt Ap is all that's needed.

[chshersh]

@chessai Well, I'm actually okay with exporting Ap. This data type looks useful and can be put in this module either implemented manually or reexported from base:

• https://github.com/kowainik/relude/blob/master/src/Relude/Monoid.hs

And them foldMapA can use Ap from Relude.Monoid module.

[chessai]

in that case, for GHC pre-8.6, you might want to just copy the code for Ap completely, and for base >= 4.12 re-export it.

[chessai]

This is all the code related to Ap:

-- | This data type witnesses the lifting of a 'Monoid' into an
-- 'Applicative' pointwise.
--
-- @since 4.12.0.0
newtype Ap f a = Ap { getAp :: f a }
        deriving ( Alternative -- ^ @since 4.12.0.0
                 , Applicative -- ^ @since 4.12.0.0
                 , Enum        -- ^ @since 4.12.0.0
                 , Eq          -- ^ @since 4.12.0.0
                 , Functor     -- ^ @since 4.12.0.0
                 , Generic     -- ^ @since 4.12.0.0
                 , Generic1    -- ^ @since 4.12.0.0
                 , Monad       -- ^ @since 4.12.0.0
                 , MonadFail   -- ^ @since 4.12.0.0
                 , MonadPlus   -- ^ @since 4.12.0.0
                 , Ord         -- ^ @since 4.12.0.0
                 , Read        -- ^ @since 4.12.0.0
                 , Show        -- ^ @since 4.12.0.0
                 )

-- | @since 4.12.0.0
instance (Applicative f, Semigroup a) => Semigroup (Ap f a) where
        (Ap x) <> (Ap y) = Ap $ liftA2 (<>) x y

-- | @since 4.12.0.0
instance (Applicative f, Monoid a) => Monoid (Ap f a) where
        mempty = Ap $ pure mempty

-- | @since 4.12.0.0
instance (Applicative f, Bounded a) => Bounded (Ap f a) where
  minBound = pure minBound
  maxBound = pure maxBound

-- | @since 4.12.0.0
instance (Applicative f, Num a) => Num (Ap f a) where
  (+)         = liftA2 (+)
  (*)         = liftA2 (*)
  negate      = fmap negate
  fromInteger = pure . fromInteger
  abs         = fmap abs
  signum      = fmap signum