在 Haskell 为什么应用程序需要在同一上下文中获取态射和数据？

Question

I am new to Haskell. This may be stupid question.

As the Applicative typeclass has apply function that takes the functions and data in the same context. Why can't it be different and be more generic.

class Functor f => Applicative f where
    pure :: a -> f a
    (<*>) :: f (a -> b) -> f a -> f b

Why can't we write something like this

class Functor f => Applicative f where
    (<*>) :: Functor g => g (a -> b) -> f a -> g (f b)
    (<*>) gab fa = fmap (\g -> fmap g fa) gab

    (<<*>>) :: Functor g => (g (f a) -> f a) -> g (a -> b) -> f a -> f b
    (<<*>>) peelOuter gab fa = peelOuter $ gab <*> fa

    (>>*<<) :: Functor g => (g (f a) -> g a) -> g (a -> b) -> f a -> g b
    (>>*<<) cleanInner gab fa = cleanInner $ gab <*> fa

It can be used as below

-- Extract List from maybe
elfm :: Maybe [a] -> [a]
elfm Nothing = []
elfm (Just xs) = xs

-- Fuse List elements in Maybe []
flem :: Monoid a => Maybe [a] -> Maybe a
flem Nothing = mempty
flem (Just xs) = Just $ foldl (<>) mempty xs

Just (*2) <*> [1,2,3,4]
-- Just [2,4,6,8]
(<<*>>) elfm (Just (*2)) [1,2,3,4]
-- [2,4,6,8]
(>>*<<) flem (Just (++ "Haskell")) ["Hello, "]
-- Just "Hello, Haskell"

And I read that the whole point of having Applicatives is the drawback of Functors lifting multi argument functions. Is this right?

And I don't think the function application is as expected.

add :: Num a => a -> a -> a
add a b = a + b

-- I want to apply [1,2,3] as First arguments and [4,5,6] as 2nd arguments.
-- Like add 1 4, add 2 4, add 3 6
-- But it is give all possibilities of combinations like a tree

--                          <*>
--      (+1)                (+2)            (+3)
-- (1+4)(1+5)(1+6)  (2+4)(2+5)(2+6)  (3+4)(3+5)(3+6)

And also they are compared to batch processing, but no quite real life example is given. Please provide an example for this.

Answer 1

Each instance of Applicative necessarily has its own implementation of <*> . That's why we have type classes in the first place. Your code has all the methods defined in the class itself, nothing is left for instances. This means there isn't much of a type class at all. There's just a bunch of generic functions. All the meat is delegated to the arguments peelOuter and cleanInner of ('<<*>>) and (>>*<<) . Let's look at them more closely. They are more or less symmetrical so (<<*>>) should be enough.

(<<*>>) :: Functor g => (g (f a) -> f a) -> g (a -> b) -> f a -> f b
(<<*>>) peelOuter gab fa = peelOuter $ gab <*> fa

It's actually peelOuter that should have been a method of a type class, but there is more than one problem with that.

The first problem that there are two functors involved, and peelOuter needs to be implemented separately for each pair of functors. That is, we would have a bi-parametric type class ApplicativePair here, and we would need a separate instance for each pair.

The second problem is that peelOuter cannot be implemented for every pair of bona fide Applicative functors. One cannot extract an Id a from a Maybe (Id a) , or a [a] from an IO [a] , or...

Worse yet, it isn't clear if it is always implementable when f and g are the same functor. Clearly, when f is a monad, then it's just a join . Not all applicatives are monads however, and join is precisely what an applicative lacks to be a monad. So peelOuter , even if such a type is implementable, would violate some monad laws. Is that a bad thing? Not necessarily, if it still follows applicative laws. You however have not supplied any laws, only a bunch of functions.

Answer 2

Any two functors are Functor and Applicative functors. This coded with newtype Compose , see Data.Functor.Compose .

So, your examples can be solved by newtype Compose .

-- Just (*2) <*> [1,2,3,4]
getCompose $ pure (*2) <*> Compose (Just [1,2,3,4])
-- or
getCompose $ (*2) <$> Compose (Just [1,2,3,4])
-- Just [2,4,6,8]

-- (<<*>>) elfm (Just (*2)) [1,2,3,4]
elfm . getCompose $ pure (*2) <*> Compose (Just [1,2,3,4])
-- or with toList (method of Foldable)
toList $ pure (*2) <*> Compose (Just [1,2,3,4])
-- or
toList $ (*2) <$> Compose (Just [1,2,3,4])
-- [2,4,6,8]

-- (>>*<<) flem (Just (++ "Haskell")) ["Hello, "]
flem . getCompose $ pure (++ "Haskell") <*> Compose (Just ["Hello, "])
-- or with toList and listToMaybe
listToMaybe . toList $ pure (++ "Haskell") <*> Compose (Just ["Hello, "])
-- or
listToMaybe . toList $ (++ "Haskell") <$> Compose (Just ["Hello, "])
-- or with head :: Foldable f => f a -> Maybe a
head $ (++ "Haskell") <$> Compose (Just ["Hello, "])
-- Just "Hello, Haskell"

---

About the last question. You have got an answer in comments by @Robin Zigmond. It wrote about the newtype ZipList . With ZipList you can do:

getZipList $ (+) <$> ZipList [1,2,3] <*> ZipList [4,5,6]
-- [5,7,9]

So, one of the purposes of newtype in Haskell is the ability to write different instances for some type.