This document discusses Functor, Applicative Functor, Foldable and Traversable type classes in Haskell. It provides examples of using fmap, pure, (<*>), foldMap, traverse and sequenceA for different types like Maybe, lists and IO. It shows how Foldable is about folding while Traversable allows transforming elements of a structure with an Applicative. Traverse is used to define sequenceA and allows rejecting elements with negatives from a list.

1. 하스켈 프로그래밍
입문 4
하스켈 학교 2016년 6월 4일
서광열

2. Functor
class Functor f where
fmap :: (a -> b) -> f a -> f b

3. Functor의 한계
> fmap (+1) [1,2,3]
[2,3,4]
> fmap (+) [1,2,3] [4,5,6]
ERROR!

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

5. Functor vs Applicative
Functor
> fmap (+1) [1,2,3]
[2,3,4]
> pure (+) <*> [1,2,3] <*> [4,5,6]
[5,6,7,6,7,8,7,8,9]

6. Applicative Maybe 정의
instance Applicative Maybe where
pure = Just
Nothing <*> _ = Nothing
(Just f) <*> x = fmap f x

7. Applicative Maybe 예제
> Just (+3) <*> Just 4
Just 7
> pure (+3) <*> Nothing
Nothing
> pure (+) <*> Just 3 <*> Just 4
Just 7
> (*) <$> Just 2 <*> Just 8
Just 16

8. Applicative []의 정의
instance Applicative [] where
pure x = [x]
fs <*> xs = [f x | f <- fs, x <- xs]

9. Applicative [] 예제
> (*) <$> [1,2,3] <*> [1,0,0,1]
[1,0,0,1,2,0,0,2,3,0,0,3]
> pure 7
7
> pure 7 :: [Int]
[7]

10. Applicative IO의 정의
instance Applicative IO where
pure = return
a <*> b = do f <- a
x <- b
return (f x)

11. Applicative IO 예제
main = do
a <- (++) <$> getLine <*> getLine
putStrLn a

12. liftA2
• 일반 함수를 두 개의 functor에 쉽게 apply 할 수 있게
해주는 함수
liftA2 :: (Applicative f) =>
(a -> b -> c) ->
f a -> f b -> f c
liftA2 f a b = f <$> a <*> b

13. liftA2 예제
> (+) <$> Just 3 <*> Just 4
Just 7
> liftA2 (+) (Just 3) (Just 4)
Just 7

14. Applicative Functor 법칙
1. pure f <*> x = fmap f x
2. pure id <*> v = v
3. pure (.) <*> u <*> v <*> w = u <*> (v <*> w)
4. pure f <*> pure x = pure (f x)
5. u <*> pure y = pure ($ y) <*> u

15. Foldable
• 리스트 foldr의 일반화
• foldr :: (a -> b -> b) -> b -> [a] -> b

16. mconcat
• foldr f z [a, b, c]
• a `f` (b `f` (c `f` z))
• f = (<>), z = mempty
• a <> (b <> (c <> mempty))
mconcat :: Monoid m => [m] -> m
mconcat = foldr mappend mempty

17. mconcat 예제
> mconcat ["Tree", "fingers"]
"Treefingers"

18. foldMap
• mconcat에서 Monoid 인스턴스 제약을 제거
foldMap :: Monoid m => (a -> m) -> [a] -> m
foldMap g = mconcat . fmap g

19. foldMap의 예제
> foldMap Sum [1..10]
Sum {getSum = 55}

20. foldr 다시 보기
• foldr :: (a -> (b -> b)) -> b -> [a] -> b
• b -> b는 composition에 대해 Monoid
• mappend = (.)
• mempty = id
newtype Endo b = Endo { appEndo :: b -> b }
instance Monoid Endo where
mempty = Endo id
Endo g `mappend` Endo f = Endo (g . f)

21. foldComposing
foldComposing :: (a -> (b -> b)) -> [a] -> Endo b
foldComposing f = foldMap (Endo . f)
foldr :: (a -> (b -> b)) -> b -> [a] -> b
foldr f z xs = appEndo (foldComposing f xs) z
• foldr을 foldMap을 이용해 정의할 수 있다는 의미

22. foldComposing 연산
1. foldComposing (+) [1, 2, 3]
2. foldMap (Endo . (+)) [1, 2, 3]
3. mconcat (fmap (Endo . (+)) [1, 2, 3])
4. mconcat (fmap Endo [(+1), (+2), (+3)])
5. mconcat [Endo (+1), Endo (+2), Endo (+3)]
6. Endo ((+1) . (+2) . (+3))
7. Endo (+6)

23. Foldable 타입 클래스
class Foldable t where
foldMap :: Monoid m => (a -> m) -> t a -> m
foldr :: (a -> b -> b) -> b -> t a -> b
• foldMap과 foldr 둘 중 하나만 정의하면 됨

24. Foldable 타입 클래스 함
수
• fold :: Monoid m => t m -> m --
generalised mconcat
• foldr' :: (a -> b -> b) -> b -> t a -
> b
• foldl :: (b -> a -> b) -> b -> t a -
> b
• foldl' :: (b -> a -> b) -> b -> t a -
> b
• foldr1 :: (a -> a -> a) -> t a -> a
• foldl1 :: (a -> a -> a) -> t a -> a
• toList :: t a -> [a]
• null :: t a -> Bool
• length :: t a -> Int
• elem :: Eq a => a -> t a -> Bool
• maximum :: Ord a => t a -> a
• minimum :: Ord a => t a -> a
• sum :: Num a => t a -> a
• product :: Num a => t a -> a

25. Data.Foldable 함수
• traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a ->
f ()
• Map each element of a structure to an action, evaluate
these actions from left to right, and ignore the results. For a
version that doesn't ignore the results see traverse.
• mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
• Map each element of a structure to a monadic action,
evaluate these actions from left to right, and ignore the
results. For a version that doesn't ignore the results see
mapM.

26. Foldable 예제
> import qualified Data.Map as M
> let testMap = M.fromList $ zip [0..] ["Yesterday","I","woke","up","sucking","a","lemon"]
> length testMap
7
> sum . fmap length $ testMap
29
> elem "lemon" testMap
True
> foldr1 (x y -> x ++ (' ' : y)) testMap
"Yesterday I woke up sucking a lemon"

27. Foldable 예제
> import Data.Foldable
> traverse_ putStrLn testMap
Yesterday
I
woke
up
sucking
a
lemon

28. Traversable
deleteIfNegative :: (Num a, Ord a) => a -> Maybe a
deleteIfNegative x = if x < 0 then Nothing else Just x
rejectWithNegatives :: (Num a, Ord a) => [a] -> Maybe [a]
• deleteIfNegative를 이용해서 rejectWithNegatives 를
구현하려면?
> let testList = [-5,3,2,-1,0]
> fmap deleteIfNegative testList
[Nothing,Just 3,Just 2,Nothing,Just 0]
No!!

29. Traversable 타입 클래
스
class (Functor t, Foldable t) => Traversable t where
traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
sequenceA :: Applicative f => t (f a) -> f (t a)
-- These methods have default definitions.
-- They are merely specialised versions of the other two.
mapM :: Monad m => (a -> m b) -> t a -> m (t b)
sequence :: Monad m => t (m a) -> m (t a)

30. Traversable [] 정의
instance Traversable [] where
-- sequenceA :: Applicative f => [f a] -> f [a]
sequenceA [] = pure []
sequenceA (u:us) = (:) <$> u <*> sequenceA us
// or
instance Traversable [] where
sequenceA us =
foldr (u v -> (:) <$> u <*> v) (pure []) us

31. Foldable vs Traversable
• Foldable
• Monoid 콘텍스트
• fold
• foldMap
• Traversable
• Applicative 콘텍스트
• sequenceA
• traverse

32. Traversable 예제
> let rejectWithNegatives = sequenceA . fmap deleteIfNegative
> :t rejectWithNegatives
rejectWithNegatives
:: (Num a, Ord a, Traversable t) => t a -> Maybe (t a)
> rejectWithNegatives testList
Nothing
> rejectWithNegatives [0..10]
Just [0,1,2,3,4,5,6,7,8,9,10]

33. traverse를 이용한
Traversable [] 정의
instance Traversable [] where
traverse _ [] = pure []
traverse f (x:xs) = (:) <$> f x <*> traverse f xs
-- Or, equivalently:
instance Traversable [] where
traverse f xs =
foldr (x v -> (:) <$> f x <*> v) (pure []) xs

34. traverse와 sequenceA
traverse :: (Traversable t, Applicative f) => (a -> f
b) -> t a -> f (t b)
traverse f xs = sequenceA $ fmap f xs
sequenceA :: (Traversable t, Applicative f) => t (f
a) -> f (t a)
sequenceA xs = traverse id xs

35. Foldable/Traversable
출처: https://wiki.haskell.org/Foldable_and_Traversable

36. 참고 자료
1. CS252 – Advanced Programming Language Principles
Applicative Functors
• http://cs.sjsu.edu/~austin/cs252-fall14/slides/CS252-
Day09-ApplicativeFunctors.pdf
2. Haskell/Foldable
• https://en.wikibooks.org/wiki/Haskell/Foldable
3. Haskell/Traversable
• https://en.wikibooks.org/wiki/Haskell/Traversable