map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn] map f [x1, x2, ...] == [f x1, f x2, ...]this means that map id == id
>>> map (+1) [1, 2, 3] [2,3,4]
>>> map id [1, 2, 3] [1,2,3]
>>> map (\n -> 3 * n + 1) [1, 2, 3] [4,7,10]
>>> mapAccumL (\a b -> (a + b, a)) 0 [1..10] (55,[0,1,3,6,10,15,21,28,36,45])
>>> mapAccumL (\a b -> (a <> show b, a)) "0" [1..5] ("012345",["0","01","012","0123","01234"])
>>> mapAccumR (\a b -> (a + b, a)) 0 [1..10] (55,[54,52,49,45,40,34,27,19,10,0])
>>> mapAccumR (\a b -> (a <> show b, a)) "0" [1..5] ("054321",["05432","0543","054","05","0"])
>>> import GHC.Internal.Text.Read ( readMaybe ) >>> let readMaybeInt = readMaybe :: String -> Maybe Int >>> mapMaybe readMaybeInt ["1", "Foo", "3"] [1,3] >>> catMaybes $ map readMaybeInt ["1", "Foo", "3"] [1,3]If we map the Just constructor, the entire list should be returned:
>>> mapMaybe Just [1,2,3] [1,2,3]
>>> let expensiveDouble a = putStrLn ("Doubling " <> show a) >> pure (2 * a) >>> :{ mapAccumM (\cache a -> case lookup a cache of Nothing -> expensiveDouble a >>= \double -> pure ((a, double):cache, double) Just double -> pure (cache, double) ) [] [1, 2, 3, 1, 2, 3] :} Doubling 1 Doubling 2 Doubling 3 ([(3,6),(2,4),(1,2)],[2,4,6,2,4,6])
>>> concatMap (take 3) [[1..], [10..], [100..], [1000..]] [1,2,3,10,11,12,100,101,102,1000,1001,1002]
>>> concatMap (take 3) (Just [1..]) [1,2,3]
>>> fmap show Nothing Nothing >>> fmap show (Just 3) Just "3"Convert from an Either Int Int to an Either Int String using show:
>>> fmap show (Left 17) Left 17 >>> fmap show (Right 17) Right "17"Double each element of a list:
>>> fmap (*2) [1,2,3] [2,4,6]Apply even to the second element of a pair:
>>> fmap even (2,2) (2,True)It may seem surprising that the function is only applied to the last element of the tuple compared to the list example above which applies it to every element in the list. To understand, remember that tuples are type constructors with multiple type parameters: a tuple of 3 elements (a,b,c) can also be written (,,) a b c and its Functor instance is defined for Functor ((,,) a b) (i.e., only the third parameter is free to be mapped over with fmap). It explains why fmap can be used with tuples containing values of different types as in the following example:
>>> fmap even ("hello", 1.0, 4) ("hello",1.0,True)
>>> foldMap Sum [1, 3, 5] Sum {getSum = 9}
>>> foldMap Product [1, 3, 5] Product {getProduct = 15}
>>> foldMap (replicate 3) [1, 2, 3] [1,1,1,2,2,2,3,3,3]When a Monoid's (<>) is lazy in its second argument, foldMap can return a result even from an unbounded structure. For example, lazy accumulation enables Data.ByteString.Builder to efficiently serialise large data structures and produce the output incrementally:
>>> import qualified Data.ByteString.Lazy as L >>> import qualified Data.ByteString.Builder as B >>> let bld :: Int -> B.Builder; bld i = B.intDec i <> B.word8 0x20 >>> let lbs = B.toLazyByteString $ foldMap bld [0..] >>> L.take 64 lbs "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24"
>>> biconcatMap (take 3) (fmap digitToInt) ([1..], "89") [1,2,3,8,9]
>>> biconcatMap (take 3) (fmap digitToInt) (Left [1..]) [1,2,3]
>>> biconcatMap (take 3) (fmap digitToInt) (Right "89") [8,9]
bifoldMap f g ≡ bifoldr (mappend . f) (mappend . g) mempty
>>> bifoldMap (take 3) (fmap digitToInt) ([1..], "89") [1,2,3,8,9]
>>> bifoldMap (take 3) (fmap digitToInt) (Left [1..]) [1,2,3]
>>> bifoldMap (take 3) (fmap digitToInt) (Right "89") [8,9]
bifoldMapDefault f g ≡ getConst . bitraverse (Const . f) (Const . g)
>>> bimapAccumL (\acc bool -> (acc + 1, show bool)) (\acc string -> (acc * 2, reverse string)) 3 (True, "foo") (8,("True","oof"))
>>> bimapAccumR (\acc bool -> (acc + 1, show bool)) (\acc string -> (acc * 2, reverse string)) 3 (True, "foo") (7,("True","oof"))
bimapDefault f g ≡ runIdentity . bitraverse (Identity . f) (Identity . g)