「学习笔记-Haskell」Chapter 11 Applicative Functions
Let’s see how IO is an instance of Functor. When we fmap a function over an I/O action, we want to get back an I/O action that does the same thing but has our function applied over its result value. Here’s the code:
instance Functor IO where fmap f action = do result <- action return (f result)
Check out this piece of code
main = do line <- getLine let line' = reverse line putStrLn $ "You said " ++ line' ++ " backwards!" putStrLn $ "Yes, you said " ++ line' ++ " backwards!"
We can rewrite it use fmap.
main = do line <- fmap reverse getLine putStrLn $ "You said " ++ line ++ " backwards!" putStrLn $ "Yes, you said " ++ line ++ " backwards!"
getLine is an I/O action that has a type of IO String, and mapping reverse over it gives us an I/O action that will go out into the real world and get a line and then apply reverse to its result.
We can also fmap multi functions to I/O action.
import Data.Charmain = do line <- fmap (reverse . map toUpper) getLine putStrLn $ "You said " ++ line ++ " backwards!"
Another instance of Functor that we’ve been dealing with all along is (->) r. If you understand the that r -> a can be write as (->) r a, you may understand what is (->) r.
How are functions functors? Let’s take a look at the implementation, which lies inControl.Monad.Instances.
instance Functor ((->) r) where fmap f g = (\x -> f (g x))
First, let’s think about fmap’s type:
fmap :: (a -> b) -> f a -> f b
Next, let’s mentally replace each f, which is the role that our functor instance plays, with (->) r.
fmap :: (a -> b) -> ((->) r a) -> ((->) r b)
Then, we change prefix to infix.
fmap :: (a -> b) -> (r -> a) -> (r -> b)
We see that it takes a function from a to b and a function from r to a and returns a function from r to b. Does this remind you of anything? Yes, function composition!
Here’s another way to write this instance.
instance Functor ((->) r) where fmap = (.)
This makes it clear that using fmap over functions is just function composition. Let's see several examples.
ghci>(*3) . (+100) $ 2306ghci>(*3) `fmap` (+100) $ 2306ghci>fmap (*3) (+100) 2306
Note that you should import Control.Monad.Instances first.
Using fmap (*3) on (+100) will create another function that acts like (+100), but before producing a result, (*3) will be applied to that result.Think about the similarity between this process with functors on IO action.
All functors are expected to exhibit certain kinds of properties and behav- iors. They should reliably behave as things that can be mapped over. This behavior is described in the functor laws. All instances of Functor should abide by these two laws.
The first functor law states that if we map the id function over a functor value, the functor value that we get back should be the same as the original functor value.
ghci>id (Just 4)Just 4ghci>fmap id (Just 4)Just 4
The second law says that composing two functions and then mapping the resulting function over a functor should be the same as first mapping one function over the functor and then mapping the other one.
fmap (f . g) = fmap f . fmap g
Let’s take a look at a pathological example of a type constructor being an instance of the Functor type class but not really being a functor, because it doesn’t satisfy the laws.
data CMaybe a = CNothing | CJust Int a deriving (Show)
Let’s play with our new type
ghci>CNothing CNothingghci>CJust 1 "hiahia"CJust 1 "hiahia"
Let’s make this an instance of Functor so that each time we use fmap, the func- tion is applied to the second field, whereas the first field is increased by 1
data CMaybe a = CNothing | CJust Int a deriving (Show)instance Functor CMaybe where fmap f CNothing = CNothing fmap f (CJust counter x) = CJust (counter+1) (f x)
ghci>fmap (++"hahia") (CJust 0 "ho")CJust 1 "hohahia"ghci>fmap (++"xxx") $ fmap (++"hahia") (CJust 0 "ho")CJust 2 "hohahiaxxx"
Does this obey the functor laws?We can find a counterexample easily.
ghci>id (CJust 0 "hia")CJust 0 "hia"ghci>fmap id (CJust 0 "hia")CJust 1 "hia"
Since CMaybe fails at being a functor even though it pretends to be one, using it as a functor might lead to some faulty code.
The next time you make a type an instance of Functor, take a minute to make sure that it obeys the functor laws.
So far, we have focused on mapping functions that take only one parameter over functors. But what happens when we map a function that takes two parameters over a functor?
ghci>:t fmap (*) (Just 3)fmap (*) (Just 3) :: Num a => Maybe (a -> a)
We see how by mapping “multiparameter” functions over functor val- ues, we get functor values that contain functions inside them. So now what can we do with them?
ghci>let a = fmap (*) (Just 3)ghci>fmap (\f -> f 4) aJust 12
You can think of this process like.
a = fmap (*) (Just 3) -> a = (Just (*) 3)-> a = (Just (3 *) )fmap (\f -> f 4) a= fmap (\f -> f 4) (Just (3 *) )= (Just (\f -> f 4) (3 *) )= (Just ((3 *) 4) )= (Just (3 * 4) )
It doesn’t provide a default implementation for either of them, so we need to define them both if we want something to be an applicative functor. The class is defined like so
class (Functor f) => Applicative f where pure :: a -> f a (<*>) :: f (a -> b) -> f a -> f b
Let’s take a look at the Applicative instance implementation for Maybe.
instance Applicative Maybe where pure = Just Nothing <*> _ = Nothing (Just f) <*> something = fmap f something
Now let’s give some examples:
ghci>Just (3+) <*> Just 4Just 7ghci>pure (3+) <*> Just 4Just 7
You see how doing pure (+3) and Just (+3) is the same in this case.
With the Applicative type class, we can chain the use of the <*> function, thus enabling us to seamlessly operate on several applicative values instead of just one.
ghci>pure (+) <*> Just 3 <*> Just 5Just 8ghci>pure (+) <*> Just 3 <*> NothingNothingghci>pure (+) <*> Nothing <*> Just 5Nothing
Instead of writing pure f <*> x <*> y <*> …, we can write fmap f x <*> y <*> …. This is why Control.Applicative exports a function called <$>, which is just fmap as an infix operator. Here’s how it’s defined:
(<$>) :: (Functor f) => (a -> b) -> f a -> f bf <$> x = fmap f x
By using <$>, the applicative style really shines, because now if we want to apply a function f between three applicative values, we can write f <$> x <*> y <*> z. If the parameters were normal values rather than ap- plicative functors, we would write f x y z.
ghci>(++) <$> Just "sdf" <*> Just "ewrq"Just "sdfewrq"
Lists (actually the list type constructor, []) are applicative functors.
instance Applicative [] where pure x = [x] fs <*> xs = [f x | f <- fs, x<-xs]
Let's look at some example to see what's the meaning of the definition above.
ghci>pure "Hia" :: [String]["Hia"]ghci>pure "Hia" :: Maybe StringJust "Hia"
ghci>[(*0),(+1),(^2)] <*> [1,2,3][0,0,0,2,3,4,1,4,9]
In the following example, we apply two function between two lists:
ghci>[(*),(+)] <*> [1,2] <*> [3,4][3,4,6,8,4,5,5,6]
Using the applicative style with lists is fun!
ghci>(++) <$> ["a","b","c"] <*> ["?","!","~"]["a?","a!","a~","b?","b!","b~","c?","c!","c~"]
Another instance of Applicative that we’ve already encountered is IO.
instance Applicative IO where pure = return a <*> b = do f <- a x <- b return (f x)
Consider this:
myAction :: IO StringmyAction = do a <- getLine b <- getLine return $ a ++ b
Another way of writing this is to use the applicative style.
myAction :: IO StringmyAction = (++) <$> getLine <*> getLine
Another instance of Applicative is (->) r, or functions.
instance Applicative ((->) r) where pure x = (\_ -> x) f <*> g = (\x -> f x ( g x))
Example:
ghci>(pure 3) "sdf"3ghci>(+) <$> (+3) <*> (*100) $ 4407ghci>(*) <$> (+3) <*> (*100) $ 42800
When we do (+) <$> (+3) <*> (*100), we’re making a function that will use + on the results of (3) and (*100) and return that. With () <$> (+3) <*> (*100) $ 5, (+3) and (*100) are first applied to 5, resulting in 8 and 500. Then + is called with 8 and 500, resulting in 508. The following example is similar.
ghci>(\x y z -> [x,y,z]) <$> (+3) <*> (*4) <*> (^2) $ 5[8,20,25]
An instance of Applicative that we haven’t encountered yet is ZipList, and it lives in Control.Applicative.
instance Applicative ZipList where pure x = ZipList (repeat x) ZipList fs <*> ZipList xs = ZipList (zipWith (\f x -> f x) fs xs)
Like normal functors, applicative functors come with a few laws.
Control.Applicative defines a function that’s called liftA2
liftA2 :: (Applicative f) => (a -> b -> c) -> f a -> f b -> f cliftA2 f a b = f <$> a <*> b
With ordinary functors, we can just map functions over one functor value. With applicative functors, we can apply a function between several functor values.
ghci>liftA2 (:) (Just 3) (Just [4])Just [3,4]
Let’s try implementing a function that takes a list of applicative values and returns an applicative value that has a list as its result value. We’ll call it sequenceA.
sequnceA :: (Applicative f) => [f a] -> f [a]sequnceA [] = pure []sequnceA (x:xs) = (:) <$> x <*> sequnceA xs
Test it!
ghci>sequnceA [Just 1, Just 2, Just 3]Just [1,2,3]ghci>sequnceA [Just 1, Nothing, Just 3]Nothingghci>sequnceA [(+1), (*2), (^3)] 3[4,6,27]
