**Course Title:** Functional Programming with Haskell: From Fundamentals to Advanced Concepts **Section Title:** Advanced Topics: Applicatives, Foldables, Traversables **Topic:** Applicative functors: Working with `pure` and `<*>` In this topic, we will explore functional programming concept of Applicative functors, introduce the key functions `pure` and `<*>`, and provide practical examples of their usage in Haskell. ### What are Applicative Functors? Applicative functors are a class of functors that provide a way to "apply" functions in a context, where the context is an applicative functor instance, typically a monad-like structure. They are used to sequence computations that take effects in a context while still working in an applicative context. Functors, applicative functors, and monads are related and they are building blocks of many modern Haskell applications. To use applicative functors in your Haskell code, you need to import the following module: ```haskell import Control.Applicative ``` ### Key Functions in Applicative Functor The applicative functor type class has two key functions: - `pure`: `a -> f a`. It takes a value and applies an identity effect, resulting in a minimal context. In simpler terms, it wraps its argument in a default functor context. - `<*>`: `f (a -> b) -> f a -> f b`. Also known as `ap`, it applies a function to the value inside a context, in sequence. Let's examine the type of `<*>`: ```haskell (<*>) :: f (a -> b) -> f a -> f b ``` The type suggests that `<*>` can apply a function to values inside arbitrary contexts. This context correspondence between the function and value happens in the same data structure (f) and is monoid for applicative cases. It gives you a context preserving computation tool. ### Examples of Using Applicative Functors Here's a brief example with `Maybe`, which is an applicative functor: ```haskell import Control.Applicative addNums :: Int -> Int -> Int addNums x y = x + y result1 :: Maybe Int result1 = Just (addNums 1 2) -- equivalent to (Just 1) <*> (Just 2) <*> pure addNums result2 :: Maybe Int result2 = pure addNums <*> (Just 1) <*> (Just 2) -- Just 3 result3 :: Maybe Int result3 = pure addNums <*> (Just 1) <*> Nothing -- Nothing, i.e., no result ``` Another simple example using a list (list is an applicative functor too): ```haskell import Control.Applicative nums = [1, 2, 3] doubleNums = [(*2), (/2)] result :: [Int] result = pure (+) <*> nums <*> nums -- all x + y where x in nums and y in nums ``` Last but not the least, `Applicative` functions can be built using the Alternative type class functions as well: ```haskell orElse::Alternative m => m a -> m a -> m a orElse = (<|>) orElse' :: Alternative m => [m a] -> m a orElse' = foldr orElse pure ``` You can practice more examples like the ones shown above to deepen your understanding and get a better grasp on different data types that are instances of Applicative. ### Summary and Further Reading In summary, this topic introduced you to key aspects of applicative functors and made you practice using the `pure` and `<*>` functions with them. Key Takeaway is `(<*>) = ap`, in the control.Monad module, whose method is map in functor and applicative, aka bind in Monad. Helpful Link to the ApplicativeFunctor tutorial using image reference in HaskellWiki. https://wiki.haskell.org/Applicative_Functors Also can see the links below for Monad library description with some parts of ApplicativeFunctor inside: https://hackage.haskell.org/package/base-4.16.1.0/docs/Control-Monad.html https://hackage.haskell.org/package/base-4.16.1.0/docs/Control-Applicative.html How's your learning experience so far? Share with us your learning progress. Leave a comment below and let's have an interesting discussion. In the next topic, we will learn how to use foldable and traversable type classes. ### After this topic is completed: Proceed to learn **Using foldable and traversable type classes.**