Haskell Study

1. Haskell
Study
14. useful monads

2. Writer Monad
이전에 다뤘던 Maybe, List, IO 등의 모나드 외의 많이 쓰이는 다른 유용한 모나드들에 대해
다뤄봅시다. 첫 번째는 Writer 모나드입니다. Writer 모나드는 작업 중간중간에 로그를 남기고 싶을
때 굉장히 유용하게 사용할 수 있습니다.
newtype Writer extra a = Writer { runWriter :: (a, extra) }
instance Monoid extra => Monad (Writer extra) where
return a = Writer (a, mempty)
Writer (a, e) >>= f =
let (b, e') = runWriter (f a) in Writer (b, e `mappend` e')
extra타입은 해당 작업의 결과로 인해 발생한 여분의 값(로그 등)의 타입이고 a 타입은 실제
작업하고자 하는 값의 타입입니다.

3. Writer Monad
Writer 모나드의 return 함수는 계산하고자 하는 값과, extra 타입의 가장 작은 값(mempty)을
묶은 튜플을 반환합니다.
Prelude> runWriter (return 3 :: Writer String Int)
(3, "")
Prelude> runWriter (return 3 :: Writer (Sum Int) Int)
(3, Sum {getSum = 0})
Prelude> runWriter (return 3 :: Writer (Product Int) Int)
(3, Product {getProduct = 1})
runWriter 함수는 Writer 타입의 값을 일반적인 튜플값으로 바꿔주는 역할을 하죠.

4. Writer Monad
Writer 모나드를 이용해 간단한 로그를 남기는 예제를 작성해봅시다.
import Control.Monad.Writer
logNumber :: Int -> Writer [String] Int
-- Writer가 아니라 writer인 것에 주의. 관련 내용은 Monad Transformer에서 다룹니다.
logNumber x = writer (x, ["Got Number: " ++ show x])
multWithLog :: Writer [String] Int
multWithLog = do
a <- logNumber 3
b <- logNumber 5
return (a*b)
Prelude> runWriter multWithLog
(15, ["Got Number: 3", "Got Number: 5"])

5. Writer Monad
앞의 예제와 같이 Writer 모나드를 사용하면 각각의 연산에 대한 결과 로그를 쉽게 남길 수 있다는
것을 알 수 있습니다. 그리고 Writer 모나드에서 유용하게 사용할 수 있는 함수로 tell이라는 함수가
있습니다.
tell :: extra -> Writer extra ()
tell e = writer ((), e)
tell 함수는 위 선언에서 볼 수 있듯이, 실제 연산 값에는 아무런 영향을 미치지 않고 여분의 값에 대해
특정 값을 추가하고 싶을 때 사용하는 함수입니다. 계산 중간중간에 원하는 로그를 삽입하고 싶을 때
사용할 수 있겠죠.

6. Writer Monad
tell을 활용하여, 두 수의 gcd를 구하는 함수의 연산 과정을 기록해봅시다.
import Control.Monad.Writer
gcdWithLog :: Int -> Int -> Writer [String] Int
gcdWithLog a b
| b == 0 = do
tell ["Finished with " ++ show a]
return a
| otherwise = do
tell [show a ++ " mod " ++ show b ++ " = " ++ show (a `mod` b)]
gcdWithLog b (a `mod` b)

7. Writer Monad
gcd 결과 값을 얻고 싶다면 함수를 수행한 Writer 값에서 첫 번째 요소를 가져오면 되고, 계산 로그가
궁금하다면 두 번째 요소를 가져오면 되겠죠.
Prelude> fst $ runWriter (gcdWithLog 8 3)
1
Prelude> snd $ runWriter (gcdWithLog 8 3)
["8 mod 3 = 2", "3 mod 2 = 1", "2 mod 1 = 0", "Finished With 1"]

8. State Monad
이번엔 State 모나드입니다. State 모나드는 상태의 변화가 필요한 연산을 구현할 때 굉장히
유용하게 쓸 수 있습니다.
newtype State s a = State { runState :: s -> (a,s) }
State s a는 s 타입의 상태와 a 타입의 결과값을 가지는 연산으로 생각할 수 있습니다.
instance Monad (State s) where
return x = State $ s -> (x,s)
(State h) >>= f = State $ s -> let (a, newState) = h s
(State g) = f a
in g newState

9. State Monad
return x = State $ s -> (x,s)
코드가 어려울 땐 타입을 기준으로 하나씩 살펴보는 것이 좋습니다.
return 함수는 원래 (Monad m) => a -> m a라는 타입을 갖고 있는데, 이 때 m이 State s이므로
여기서 return 함수는 a -> State s a 라는 타입을 가지게 됩니다. 그래서 return x는 상태 s를
인자로 받아 결과값 x와 상태 s의 튜플을 돌려주는 연산으로 정의됩니다.

10. State Monad
(State h) >>= f = State $ s -> let (a, newState) = h s
(State g) = f a
in g newState
State 모나드에서 >>= 함수는 두 개의 stateful한 연산을 이어주는 역할을 한다고 생각하면 됩니다.
역시 타입부터 하나씩 살펴봅시다.
원래 >>= 함수는 (Monad m) => m a -> (a -> m b) -> m b 라는 타입을 갖고 있습니다.
따라서 여기서는 타입이 State s a -> (a -> State s b) -> State s b가 되겠죠.
그리고 State s a의 내부에 저장된 값은 s -> (a,s)라는 타입을 가집니다. 이 타입을 머릿 속에
잘 새겨둔 상태에서 다음 슬라이드들을 따라가봅시다.

11. State Monad
(State h) >>= f = State $ s -> let (a, newState) = h s
(State g) = f a
in g newState
우선 결과값은 State 값 생성자로 시작하고, 이 생성자에 람다를 인자로 주고 있습니다. 따라서 이
람다의 타입은 s -> (b,s)가 되어야겠죠.

12. State Monad
(State h) >>= f = State $ s -> let (a, newState) = h s
(State g) = f a
in g newState
따라서 람다의 인자 s는 타입 s를 가지게 됩니다(타입 / 값 헷갈리면 안돼요!). 여기서 이제 let ~ in
구문이 나오죠. let 구문 안 쪽의 내용부터 봅시다.

13. State Monad
(State h) >>= f = State $ s -> let (a, newState) = h s
(State g) = f a
in g newState
h s의 결과값을 (a, newState)로 나타내고 있습니다. h 함수는 처음에 말했듯이 s -> (a,s)
타입 서명을 갖고 있죠. 따라서 a값은 a 타입, newState값은 s 타입을 갖게 됩니다. 의미 상으로는
주어진 상태 s에 첫번째 stateful한 연산 h를 적용한 결과, 결과값 a와 바뀐 상태 newState를
얻었다고 할 수 있을 겁니다.

14. State Monad
(State h) >>= f = State $ s -> let (a, newState) = h s
(State g) = f a
in g newState
이제 그 상태에서 f a의 결과값을 State g로 나타내고 있죠. f 함수는 a -> State s b 타입을
갖고 있으니, g 함수는 s -> (b,s) 타입을 갖게 될 겁니다. 의미적으로는, h 함수를 적용한
결과 얻은 a 값을 이용하는 두 번째 stateful한 연산 g를 f 함수를 이용해 구하는 것으로 생각할 수
있습니다.

15. State Monad
(State h) >>= f = State $ s -> let (a, newState) = h s
(State g) = f a
in g newState
그리고 in 이후 구문에서 이렇게 얻은 새로운 stateful 연산 g에 newState를 넘기고 있죠. 그 결과는
g 함수의 타입이 s -> (b,s)이므로 (b,s) 타입이 될겁니다. 즉, 람다는s 타입의 값을 받아 (b,s)
타입을 리턴하고, 그러니 (State h) >>= f 의 최종 결과 타입은 State s b가 되겠죠.
따라서 (State h) >>= f 라는 식은 의미적으로는 stateful한 연산인 h 함수를 수행한 후, 그
결과값을 이용하는 stateful 연산 g에 h를 수행한 후의 현재 상태(newState)를 넘긴 후의 결과
(b,s), 즉 g 함수의 결과로 얻은 b타입의 값과 새로운 상태 s를 얻는 것으로 생각할 수 있죠. 결국 두
개의 stateful한 연산을 자연스럽게 하나로 엮어주게 되는 것입니다.

16. stack
State 모나드를 활용하는 예제로 stack를 생각해봅시다. stack은 push와 pop이라는 두 가지
연산을 지원합니다. push / pop은 현재의 stateful한 연산이므로 State 모나드를 이용해 구현할 수
있겠죠.
import Control.Monad.State
type Stack a = [a]
--역시 State가 아니라 state인 것에 주의.
push :: a -> State (Stack a) ()
push val = state $ s -> ((), val:s)
pop :: State (Stack a) a
pop = state $ (top:s) -> (top,s)

17. stack
이제 이렇게 구현한 stack을 한 번 테스트해봅시다.
stackTest :: State (Stack a) (a,a)
stackTest = do
a <- pop
push a
b <- pop
return (a,b)
ghci> runState stackTest [1,2,3]
((1,1),[2,3])
ghci> runState stackTest [5,4,3,2,1]
((5,5),(4,3,2,1))

18. Random
다른 유용한 State 모나드 활용 예제로는 random이 있습니다. System.Random 모듈에 있는 난수
생성 함수 random은 아래와 같은 타입을 갖고 있죠.
random :: (RandomGen g, Random a) => g -> (a, g)
이 함수는 난수의 시드값 역할을 할 수 있는 RandomGen 타입 클래스에 속하는 타입 g와, Random
타입 클래스에 속하는 타입 a에 대해 g 값을 받아 난수값 a와 그 이후 시드값 g의 튜플 (a,g)를
반환하는 함수입니다. 저 타입으로부터 random이 stateful 한 함수이며 따라서 State 모나드를
활용할 수 있다는 걸 알 수 있죠.
randomSt :: (RandomGen g, Random a) => State g a
randomSt = state random

19. Random
이제 randomSt 함수를 이용하면 여러 개의 random 값을 손쉽게 얻어낼 수 있습니다.
import System.Random
import Control.Monad.State
threeRandom :: State StdGen (Bool, Bool, Bool)
threeRandom = do
a <- randomSt
b <- randomSt
c <- randomSt
return (a,b,c)
ghci> runState threeRandom (mkStdGen 10)
((True, False, False),356856746 2103410263)

20. Useful functions
모나드를 쓸 때 유용한 함수 몇 가지를 살펴봅시다. 우선 liftM 함수와 ap 함수입니다.
liftM :: (Monad m) => (a -> b) -> m a -> m b
이 함수는 Monad에 대해 동작한다는 점만 다를 뿐 Functor의 fmap과 동일합니다. Monad가
Functor보다 더 나아간 개념이므로 Monad에 대해서도 fmap과 동일한 연산을 수행할 수 있는 것은
당연하겠죠.
ap :: (Monad m) => m (a -> b) -> m a -> m b
ap역시 Monad에 대해 동작한다는 점만 다를 뿐 Applicative Functor의 <*>과 동일합니다.

21. Useful functions
ghci> liftM (*2) (Just 5)
Just 10
ghci> liftM (*3) Nothing
Nothing
ghci> liftM (*5) [1,2,3]
[5,10,15]
ghci> Just (*2) `ap` Just 4
Just 8
ghci> Nothing `ap` Just 5
Nothing
ghci> [(*2),(+3)] `ap` [1,2,3]
[2,4,6,4,5,6]

22. Useful functions
다음은 filterM입니다. 고차함수를 다룰 때 나왔던 filter 함수가 list에 대해서만 동작하는 것이었다면,
filterM 함수는 그걸 일반적인 Monad 차원으로 확장시킨 함수입니다. 이 함수의 타입은 아래와
같습니다.
filter :: (a -> Bool) -> [a] -> [a]
filterM :: (Monad m) => (a -> m Bool) -> [a] -> m [a]
이 filterM 함수를 사용하면 해당 monad의 컨텍스트와 관련된 filter 함수를 수행할 수 있습니다.

23. Useful functions
ghci> filterM (_ -> Just True) [1,2,3]
Just [1,2,3]
ghci> filterM (x -> if x == 2 then Just True else Just False) [1,2,3]
Just [2]
ghci> filterM (_ -> Nothing) [1,2,3]
Nothing
위와 같이 Maybe 모나드에 대해 filterM 함수를 쓰면 원래 Maybe 모나드가 가진 컨텍스트인
'실패할 수 있는 연산'이 그대로 적용된다는 걸 알 수 있습니다. Nothing이 하나라도 포함되면
Nothing, 그렇지 않다면 술어함수를 통과한 값만 남기죠. 그렇다면 list 타입에 대한 filterM은 어떻게
동작할까요? 역시 마찬가지로 list 타입이 지닌 컨텍스트인 '비결정성'을 그대로 가지고 동작합니다.

24. Useful functions
이 비결정성이라는 특징을 이용해 어떤 집합의 멱집합(powerset - 해당 집합의 부분집합으로
이루어진 집합)을 쉽게 구할 수 있습니다.
powerset :: [a] -> [[a]]
powerset = filterM (x -> [True, False])
ghci> powerset [1,2,3]
[[1,2,3],[1,2],[1,3],[1],[2,3],[2],[3],[]]