하스켈의 특징
● Purefunction
● High order function
● Polymorphism
● Lazy evaluation
● Type class
● Monad
왜 하스켈은 이런 특징을 가지는가?
8.
소프트웨어 공학적 접근
재사용(Reusability)
●이미 만들어진 설계, 코드, 테스트, 문서 등을 재사용할 수 있어야 한다.
분할 정복(divide and conquer)
● 복잡한 문제는 작은 단위로 나눠서 풀고 재조합한다.
그래서 조합성(compositionality)이 중요!
9.
프로그래밍의 본질
● 프로그래밍본질은 조합(compositin)
● 바꿔 말해, 복잡한 문제를 분해(decomposition)하고 재조합(recomposition)
하는 일
○ Category: The Essence of Composition, https://bartoszmilewski.
com/2014/11/04/category-the-essence-of-composition/
10.
함수 언어 =조합 언어
함수 언어의 모든 기능은 조합을 쉽게 하기 위한 방법
● 다형성 + 고차 함수 = 재사용성
○ Higher-order + Polymorphic = Reusable, https://kar.kent.ac.
uk/21504/3/Higher-order_+_Polymorphic_=_Reusable.pdf
● 지연 연산 = 모듈성
○ Why Functional Programming Matters, https://www.cs.kent.ac.
uk/people/staff/dat/miranda/whyfp90.pdf
11.
표기법
● 기본 타입:Int, Char, String
● 타입 변수: a, b, c
● 함수 타입: Int -> String, a -> b
● 함수: f, g, h
12.
합수 합성
● f:: A -> B
● g :: B -> C
● g . f :: A -> C
법칙
● (f . g) . h = f . (g . h)
● f . id = f
● id . f = f
범주(Category)
class Category catwhere
id :: cat a a
(.) :: cat b c -> cat a b -> cat a c
법칙
● (f . g) . h = f . (g . h)
● f . id = f
● id . f = f
instance Category (->) where
id x = x
(f . g) x = f (g x)
1. 오류
data Maybea = Just a | Nothing
f :: A -> Maybe B
g :: B -> Maybe C
g . f :: ??
Maybe를 리턴하는 함수는 (.)로 조합이 불가능
19.
오류 발생 가능한함수의 조합
return :: (a -> Maybe a)
return = Just
(<=<) :: (b -> Maybe c) -> (a -> Maybe b) -> (a -> Maybe c)
(f <=< g) x =
case g x of
Just y -> f y
Nothing -> Nothing
20.
함수 합성과의 비교
id:: (a -> a)
return :: (a -> Maybe a)
(.) :: (b -> c) -> (a -> b) -> (a -> c)
(<=<) :: (b -> Maybe c) -> (a -> Maybe b) -> (a -> Maybe c)
(f . g) x = f (g x)
(f <=< g) x = f =<< (g x)
21.
2. 비결정성
data Lista = Cons a (List a) | Nil
f :: A -> [B]
g :: B -> [C]
g . f :: ??
리스트를 리턴하는 함수는 (.)로 조합이 불가능
22.
비결정적 함수의 조합
return:: (a -> [a])
return a = [a]
(<=<) :: (b -> [c]) -> (a -> [b]) -> (a -> [c])
(f <=< g) x = concatMap f (g x)
23.
함수 합성과의 비교
id:: (a -> a )
return :: (a -> [a])
(.) :: (b -> c ) -> (a -> b ) -> (a -> c )
(<=<) :: (b -> [c]) -> (a -> [b]) -> (a -> [c])
(f . g) x = f (g x)
(f <=< g) x = concatMap f (g x)
24.
3. 콘텍스트
f ::A -> (R -> B)
g :: B -> (R -> C)
g . f :: ??
콘텍스트를 인자로 받는 함수는 (.)로 조합이 불가능
25.
콘텍스트 함수의 조합
return:: a -> (r -> a)
return a = r -> a
(<=<) :: (b -> (r -> c)) -> ((a -> (r -> b)) -> (a -> (r -> c))
(f <=< g) x = r -> f ((g x) r) r
26.
함수 합성과의 비교
id:: (a -> a)
return :: (a -> (r-> a))
(.) :: (b -> c) -> (a -> b) -> (a -> c)
(<=<) :: (b -> (r -> c)) -> (a -> (r -> b)) -> (a -> (r -> c))
(f . g) x = f (g x)
(f <=< g) x = r -> f ((g x) r) r
27.
4. IO
f ::A -> IO B
g :: B -> IO C
g . f :: ??
IO 함수는 (.)로 조합이 불가능
28.
IO 함수의 조합
return:: (a -> IO a)
(<=<) :: (b -> IO c) -> (a -> IO b) -> (a -> IO c)
29.
함수 합성과의 비교
id:: (a -> a)
return :: (a -> IO a)
(.) :: (b -> c) -> (a -> b) -> (a -> c)
(<=<) :: (b -> IO c) -> (a -> IO b) -> (a -> IO c)
(f . g) x = f (g x)
(f <=< g) x = f =<< (g x)
클라이슬리 범주(Kleisli Category)
return:: (Monad m) => (a -> m a)
(<=<) :: (Monad m) => (b -> m c) -> (a -> m b) -> (a -> m c)
newtype Kleisli m a b = Kleisli { runKleisli :: a -> m b }
instance Monad m => Category (Kleisli m) where
id = Kleisli return
(Kleisli f) . (Kleisli g) = Kleisli (f <=< g)
32.
모나드
class Monad mwhere
(>>=) :: m a -> (a -> m b) -> m b
return :: a -> m a
● (a >>= f) = (f <=< id) a
● (f <=< g) x = f =<< (g x)
33.
모나드 법칙
범주 법칙
●return <=< f = f
● f <=< return = f
● (f <=< g) <=< h = f <=< (g <=< h)
모나드 법칙
● m >>= return = m
● return x >>= f = f x
● m >>= (y -> g y >>= f) = (m >>= g) >>= f