## Monoidal Functor is Applicative but where is the Monoid typeclass in the definition of Applicative?

functor, applicative, monad

applicative functor scala

haskell monad

haskell

applicative programming with effects

haskell fmap

haskell monoid

Applicative is a Monoidal Functor :

mappend :: f -> f -> f $ :: (a -> b) -> a -> b <*> :: f(a -> b) -> f a -> f b

But I don't see any reference about Monoid in the definition of the Applicative typeclass, could you tell me why ?

Definition :

class Functor f => Applicative (f :: * -> *) where pure :: a -> f a (<*>) :: f (a -> b) -> f a -> f b GHC.Base.liftA2 :: (a -> b -> c) -> f a -> f b -> f c (*>) :: f a -> f b -> f b (<*) :: f a -> f b -> f a {-# MINIMAL pure, ((<*>) | liftA2) #-}

No mention of that structural Monoid is provided in this definition, but when you do

> ("ab",(+1)) <*> ("cd", 5) >("abcd", 6)

You can clearly see the use of a Structural Monoid "(,) String" when implementing this instance of Applicative.

Another example to show that a "Structural Monoid" is used :

Prelude Data.Monoid> (2::Integer,(+1)) <*> (1::Integer,5) <interactive>:35:1: error: • Could not deduce (Monoid Integer) arising from a use of ‘<*>’ from the context: Num b bound by the inferred type of it :: Num b => (Integer, b) at <interactive>:35:1-36 • In the expression: (2 :: Integer, (+ 1)) <*> (1 :: Integer, 5) In an equation for ‘it’: it = (2 :: Integer, (+ 1)) <*> (1 :: Integer, 5)

The monoid that's referred to with "monoidal functor" is not a `Monoid`

monoid, i.e. a value-level monoid. It's a *type-level monoid* instead. Namely, the boring product monoid

type Mempty = () type a <> b = (a,b)

(You may notice that this is not strictly speaking a monoid; it's only if you consider `((a,b),c)`

and `(a,(b,c))`

as the same type. They are sure enough isomorphic.)

To see what this has to do with `Applicative`

, resp. monoidal functors, we need to write the class in other terms.

class Functor f => Monoidal f where pureUnit :: f Mempty fzip :: f a -> f b -> f (a<>b) -- an even more "general nonsense", equivalent formulation is -- upure :: Mempty -> f Mempty -- fzipt :: (f a<>f b) -> f (a<>b) -- i.e. the functor maps a monoid to a monoid (in this case the same monoid). -- That's really the mathematical idea behind this all.

IOW

class Functor f => Monoidal f where pureUnit :: f () fzip :: f a -> f b -> f (a,b)

It's a simple exercise to define a generic instance of the standard `Applicative`

class in terms of `Monoidal`

, vice versa.

Regarding `("ab",(+1)) <*> ("cd", 5)`

: that doesn't have much to do with `Applicative`

in general, but only with the writer applicative specifically. The instance is

instance Monoid a => Monoidal ((,) a) where pureUnit = (mempty, ()) fzip (p,a) (q,b) = (p<>q, (a,b))

**Functors, Applicative Functors and Monoids,** Typeclasses are open, which means that we can define our own data type, think about what it can act like and connect it with the typeclasses that define its Applicative is a Monoidal Functor : mappend :: f -> f -> f $ :: (a -> b) -> a -> b <*> :: f(a -> b) -> f a -> f b But I don't see any reference about Monoid in the definition of the Applicative typeclass, could you tell me why ?

**Applicatives are monoidal,** Tags: Haskell, Applicative, monoids, typeclasses. Contents For both Functor and Applicative the type constructor must be of kind * -> * . Type constructor here means what it says: given a type argument, it constructs a type. It starts the definition of the Applicative class and it also introduces a class constraint. It says that if we want to make a type constructor part of the Applicative typeclass, it has to be in Functor first. That's why if we know that if a type constructor is part of the Applicative typeclass, it's also in Functor, so we can use fmap on it.

I wanted to complement Conor McBride's (pigworker) instructive answer with some more examples of `Monoid`

s found in `Applicative`

s.
It has been observed that the `Applicative`

instance of some functors resembles a corresponding `Monoid`

instance;
for example, we have the following analogies:

Applicative → Monoid --------------------- List → Product Maybe → All Either a → First a State s → Endo s

Following Conor's comment, we can understand *why* we have these correspondences.
We use the following observations:

- The shape of an
`Applicative`

container forms a`Monoid`

under the application operation`<*>`

. - The shape of a functor
`F`

is given by`F 1`

(where`1`

denotes the unit`()`

).

For each of the `Applicative`

functors listed above, we compute their shape by instantiating the functor with the unit element.
We get that...

`List`

has the shape of `Nat`

:

List a = μ r . 1 + a × r List 1 = μ r . 1 + 1 × r ≅ μ r . 1 + r ≅ Nat

`Maybe`

has the shape of `Bool`

:

Maybe a = 1 + a Maybe 1 = 1 + 1 ≅ Bool

`Either`

has the shape of `Maybe`

:

Either a b = a + b Either a 1 = a + 1 ≅ Maybe a

`State`

has the shape of `Endo`

:

State s a = (a × s) ^ s State s 1 = (1 × s) ^ s ≅ s ^ s ≅ Endo s

The types of the shapes match precisely the types underlying the `Monoid`

s listed in the beginning.
One thing still puzzles me: some of these types admit multiple `Monoid`

instances (*e.g.*, `Bool`

can be made into a `Monoid`

as `All`

or `Any`

) and I'm not entirely sure why we get one of the instances and not the other. My guess would be that this is related to the applicative laws and how they interact with the other component of the container – its positions.

**Applicative monoids,** In order to escape the need for flexible contexts, you'll have to define a It's going to be an applicative functor of monoids, so perhaps the use of the letter f, but the type itself doesn't constrain f to any type class. It seems that any applicative functor that contains monoidal values itself forms a monoid. A braided monoidal functor is a monoidal functor between braided monoidal categories (with braidings denoted ) such that the following diagram commutes for every pair of objects A, B in : A symmetric monoidal functor is a braided monoidal functor whose domain and codomain are symmetric monoidal categories .

**Typeclassopedia,** 7.1 Standard monad transformers; 7.2 Definition and laws What the heck is a monoid, and how is it different from a monad? Gain a deep intuition for each type class and its relationship to other type A somewhat newer addition to the pantheon of standard Haskell type classes, applicative functors Applicative functors are the programming equivalent of lax monoidal functors with tensorial strength in category theory. Applicative functors were introduced in 2007 by Conor McBride and Ross Paterson in their paper Functional Pearl: applicative programming with effects.

**Functortown: Applicative,** This series covers the 'Applicative' typeclass and two of its close relatives, applicative functors, we look at the laws of the class and property testing them with as applicative functors and the connection between monoids and applicatives. at IO as an Applicative , what it means to say that functors compose, and how to The existence of two legal implementations of (<*>) for lists which only differ in the sequencing of effects indicates that [] is a non-commutative applicative functor. A commutative applicative functor, by contrast, leaves no margin for ambiguity in that respect. More formally, a commutative applicative functor is one for which the following holds:

**The Const Applicative and Monoids · in Code,** The Applicative typeclass has a somewhat infamous reputation for having opaque laws. instance Functor IntConst where fmap _ (IntConst w) = IntConst w The fact that we have Applicative laws and expectations means we can look to fit the Applicative laws…and those properties are exactly monoidal This module describes a structure intermediate between a functor and a monad (technically, a strong lax monoidal functor). Compared with monads, this interface lacks the full power of the binding operation >>=, but. it has more instances. it is sufficient for many uses, e.g. context-free parsing, or the Traversable class.

##### Comments

`f`

has the wrong kind to be`Monoid`

.- yeah but how could we express it in Applicative ? are we limited by what haskell can do ? I'd like to understand why we see nothing about Monoid when we look at the definition..
- Because the term "monoidal functor" is one chunk that can't be broken into to pieces, "a monoid and a functor". It means a functor that acts on a monoidal category and preserves the monoidal structure of that category; and again here "monoidal category" is a single term that can't be broken in two.
`Monoid`

does not cover all monoids that can be expressed in Haskell, but only those on ordinary types (that is, things with`*`

kind, as Lee alludes to).- @NicolasHenin It is expressed in the instance declaration for a particular
`Applicative`

, namely,`instance Monoid a => Applicative ((,) a)`

; and the`Monoid`

constraint in that instance declaration has no relation to the "monoidal-functor-ness" of`Applicative`

as a concept. - Categorical monoids are only associative up to isomorphism, so it's OK.
- I always find it awkward to pick a name (or an operator symbol) to talk about the
`f a -> f b -> f (a,b)`

combinator (or its uncurried version).`fzip`

is not half bad -- in fact, I might end up adopting it. - @duplode well, I thought a lot about these names when I wrote the constrained
`Applicative`

class. (There I actually had to use uncurried and category-agnostic signatures, which makes it a whole lot more awkward.) - @leftaroundabout I had forgotten about looking in your
*constrained-categories*while looking for existing names on Hackage (and, as you can imagine, my Hoogle/Hayoo searches by type signature didn't lead me to it). - It's a actually a concept of multiplication where you factorize the f, and this is maybe where the * from <*> is coming from.... and actually that operation of factorization is the application of the monoid on the functor structure I was talking about earlier... "that doesn't have much to do with Applicative in general," @leftaroundabout, I disagree with that statement, the functor in that context is (a,_) and then you need to provide a way to do that factorization with (,) and a together... This is why when you implement a applicative for tuple, a needs to be a monoid.
- Who is the Hancock you are referencing?
- One library that offers the
`AppM`

newtype at the very beginning of this answer is*reducers*, where it is called`Ap`

.