Recommended
PDF
PDF
PDF
PDF
PDF
PDF
PDF
PDF
PDF
PDF
PDF
PDF
PDF
Start IoT with JavaScript - 5.๊ฐ์ฒด2
PDF
Start IoT with JavaScript - 4.๊ฐ์ฒด1
PPTX
[์๊ฟ์ฌ] The C++ Programming Language 11์ฅ ์ฐ์ฐ์ ์ค๋ฒ๋ก๋ฉ
PDF
Start IoT with JavaScript - 2.์ฐ์ฐ์
PDF
Reflect package แแ
กแแ
ญแผแแ
กแแ
ต
PPTX
แแ
กแแ
ตแแ
ฅแซแแ
ฅแผแ
แ
ต 20160130
PPTX
Matplotlib ๊ธฐ์ด ์ดํดํ๊ธฐ_20160730
PDF
PDF
Start IoT with JavaScript - 6.ํจ์
PPTX
Processing ๊ธฐ์ด ์ดํดํ๊ธฐ_20160713
PPTX
แแ
กแแ
ตแแ
ฅแซ Numpy แแ
ฅแซแแ
งแผแแ
ขแแ
ฎ แแ
ตแแ
ขแแ
กแแ
ต
PPTX
แแ
กแแ
ตแแ
ฅแซ+Operator+แแ
ตแแ
ขแแ
กแแ
ต 20160409
PPTX
PPTX
Python ์ดํดํ๊ธฐ 20160815
PPTX
แแ
กแแ
ตแแ
ฅแซ แแ
ฎแซแแ
กแแ
งแฏ แแ
ตแแ
ขแแ
กแแ
ต
PPTX
ํ์ด์ฌ ํฌ๋กค๋ง ๋ชจ๋
PDF
แแ
กแแ
ณแแ
ฆแฏ แแ
ฉแแ
กแแ
ณ
PPTX
More Related Content What's hot
PDF
PDF
PDF
PDF
PDF
Start IoT with JavaScript - 5.๊ฐ์ฒด2
PDF
Start IoT with JavaScript - 4.๊ฐ์ฒด1
PPTX
[์๊ฟ์ฌ] The C++ Programming Language 11์ฅ ์ฐ์ฐ์ ์ค๋ฒ๋ก๋ฉ
PDF
Start IoT with JavaScript - 2.์ฐ์ฐ์
PDF
Reflect package แแ
กแแ
ญแผแแ
กแแ
ต
PPTX
แแ
กแแ
ตแแ
ฅแซแแ
ฅแผแ
แ
ต 20160130
PPTX
Matplotlib ๊ธฐ์ด ์ดํดํ๊ธฐ_20160730
PDF
PDF
Start IoT with JavaScript - 6.ํจ์
PPTX
Processing ๊ธฐ์ด ์ดํดํ๊ธฐ_20160713
PPTX
แแ
กแแ
ตแแ
ฅแซ Numpy แแ
ฅแซแแ
งแผแแ
ขแแ
ฎ แแ
ตแแ
ขแแ
กแแ
ต
PPTX
แแ
กแแ
ตแแ
ฅแซ+Operator+แแ
ตแแ
ขแแ
กแแ
ต 20160409
PPTX
PPTX
Python ์ดํดํ๊ธฐ 20160815
PPTX
แแ
กแแ
ตแแ
ฅแซ แแ
ฎแซแแ
กแแ
งแฏ แแ
ตแแ
ขแแ
กแแ
ต
PPTX
ํ์ด์ฌ ํฌ๋กค๋ง ๋ชจ๋
Viewers also liked
PDF
แแ
กแแ
ณแแ
ฆแฏ แแ
ฉแแ
กแแ
ณ
PPTX
PPS
PPTX
Learn Haskell The Easy Way
PDF
Functional Programming by Examples using Haskell
PDF
Haskell in the Real World
PDF
[IGC] ์์จ์ํํธ ์ด๊ฒฝ์ข
- ๊ฐํ ํ์ต์ ์ด์ฉํ NPC AI ๊ตฌํ
PDF
Functional programming with haskell
PDF
๋ฒ์ ๊ด๋ฆฌ๋ฅผ ๋ค์ด๋ณธ์ ์๋ ์ฌ๋๋ค์ ์ํ DVCS - Git
PDF
[NDC 2010] ๊ทธ๋ด๋ฏํ ๋๋ค ์์ฑ ์ปจํ
์ธ ๋ง๋ค๊ธฐ
PDF
Real World Haskell: Lecture 1
PDF
[NDC 2009] ํ๋ ํธ๋ฆฌ๋ก ๊ตฌํํ๋ ์ธ๊ณต์ง๋ฅ
Similar to Haskell study 8
PPTX
ํ์ค์ผ ํ๋ก๊ทธ๋๋ฐ ์
๋ฌธ 2
PPTX
PDF
PDF
Finding Functional Programming
PDF
PPTX
ํ์ค์ผ ํ๋ก๊ทธ๋๋ฐ ์
๋ฌธ
PPTX
9์ฅ10์ฅ,stl abstract interface
PPTX
STLํ์ฉ, abstract interface
PPTX
๋ชจ์ด ์ดํํฐ๋ธ c++ 5์ฅ ์คํฐ๋
PPTX
Abstract syntax semantic analyze
PPTX
์ข
์ด์ ๊ธฐ(fold) ํ๋ก๊ทธ๋๋ฐ
PDF
Pure Function and Honest Design
PDF
PDF
C++ Advanced ๊ฐ์ 4์ฃผ์ฐจ
PDF
PPTX
PDF
[Effective Modern C++] Chapter1 - item1
PDF
PDF
More effective c++ chapter4 แแ
ตแแ
ฎ แแ
กแผแแ
ฉแจ 29แแ
กแแ
ต
PPTX
More from Nam Hyeonuk
PPTX
Next ๊ฒ์ ์ค์ ํ๋ก์ ํธ ์ฌ๋ผ์ด๋
PDF
PDF
PDF
PDF
PDF
PDF
PDF
PDF
Iocp ๊ธฐ๋ณธ ๊ตฌ์กฐ ์ดํด
PDF
PDF
Effective c++ chapter 1,2 ์์ฝ
PDF
๊ตฌ๋ฌธ๊ณผ ์๋ฏธ๋ก (์ ์ ์๋ฏธ๋ก ๊น์ง)
PDF
PDF
PDF
Age Of Empires II : Age Of Kings Postmotem
Haskell study 8 1. 2. Context
Haskell์ ํ์
์์ฑ์๋ ์ผ์ข
์ ๋ฌธ๋งฅ(Context)๊ณผ ๊ฐ์ด ์ทจ๊ธํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด Maybe ํ์
์์ฑ์๋ Maybe ๋ผ๋ ๋ฌธ๋งฅ๊ณผ ๊ทธ ๋ฌธ๋งฅ ์์ ํ์
(Int, Char ๋ฑ)์ผ๋ก ์๊ฐํ ์ ์์ฃ .
Maybe
Int
Maybe Int์์ Maybe๋ ํด๋น ํ์
์ ๋ํ Context์
๋๋ค. Maybe๋ ๋ถํ์ค์ฑ- ์ฆ, ๊ฒฐ๊ณผ๊ฐ
์กด์ฌํ ์๋(Just Int) ๊ทธ๋ ์ง ์์์๋(Nothing)์๋ค๋ผ๋ ๋ถ๊ฐ์ ์ธ ๋ฌธ๋งฅ ์ ๋ณด๋ฅผ ๊ฐ์ง๋๋ค.
ํ์
์์ฑ์๋ฅผ ์ด๋ฐ ๋ฌธ๋งฅ์ ๊ด์ ์์ ๋ดค์ ๋ ํน์ ํ์
์์ฑ์์ ๋ํ ํ์
ํด๋์ค๋ ๊ทธ ๋ฌธ๋งฅ ๊ณ ์ ์
ํ๋์ ์ ์ํ๋ ๊ฒ์ผ๋ก ์๊ฐํ ์ ์์ต๋๋ค.
3. Functor
Functor ํ์
ํด๋์ค๋ context์ ๋ํด ํจ์๋ฅผ ์ ์ฉํ ์ ์๋ ํ์
๋ค์ ์งํฉ์
๋๋ค. Functor ํ์
ํด๋์ค๋ ๋ค์ ํ๋์ ํจ์ ์ธํฐํ์ด์ค๋ง์ ๊ฐ๊ณ ์์ต๋๋ค.
class Functor f where
fmap :: ( a -> b ) -> f a -> f b
Functor๋ a -> b ํจ์๋ฅผ ํ๋ ๋ฐ์์, context f ๋ด์ ์๋ a ํ์
์ ์์์ ๊ทธ ํจ์๋ฅผ ์ ์ฉ์ํจ
๊ฒฐ๊ณผ f b ๋ฅผ ๋ง๋ค์ด๋ด๋ ํจ์ fmap์ ์ธ ์ ์๋ ํ์
๋ค์ ์งํฉ์
๋๋ค. list ์ญ์ ์ผ์ข
์ context๋ก ๋ณผ
์ ์๊ณ (ํ์
์์ฑ์์ด๋ฏ๋ก), ์ด ๋ list์ ๋ํ fmap์ ์ฐ๋ฆฌ๊ฐ ๊ณ์ ์จ์๋ map์
๋๋ค.
map :: ( a -> b ) -> [a] -> [b]
list context์ ๋ํ fmap์ ํด๋น list ๋ด๋ถ์ ์ํ ์์ ์ ์ฒด์ ๋ํด ํด๋น ํจ์๋ฅผ ์ ์ฉ์ํค๋ ๊ฒ์ด์ฃ .
4. Functor
Maybe ํ์
์ ๋ํ Functor๋ ๋ค์๊ณผ ๊ฐ์ด ์ ์๋ฉ๋๋ค.
instance Functor Maybe where
fmap _ Nothing = Nothing
fmap f (Just a) = Just (f a)
Maybe ํ์
์ Context ์ธก๋ฉด์์ ๋ดค์ ๋ ๋ถํ์ค์ฑ(์กด์ฌํ๋์ง ์๋์ง - ์ฑ๊ณตํ๋์ง ์คํจํ๋์ง
์ ์ ์์)์ ์๋ฏธํ๊ธฐ ๋๋ฌธ์, ๊ทธ ๋ด๋ถ์ ์ด๋ค ๊ฐ๋ ์๋ค๋ฉด(Nothing) ๊ฒฐ๊ณผ๋ก Nothing์ ๋ฐํํ๊ณ ,
๊ทธ๋ ์ง ์๋ค๋ฉด Context ๋ด๋ถ์ ์ํ ๊ฐ(Just a์์ a)์ ํจ์๋ฅผ ์ ์ฉํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํฉ๋๋ค.
5. Functor
Functor๋ ์์ Context์ ๋ํด ๋์ํ๋ ํจ์๋ฅผ ๋ง๋ค๊ณ ์ถ์ ๋ ์ ์ฉํฉ๋๋ค.
threeRepeat :: (Functor f) => f a -> f [a]
threeRepeat = fmap (replicate 3)
์์ ๊ฐ์ ํจ์๊ฐ ์๋ค๊ณ ํฉ์๋ค. ์ด ํจ์๋ ์ธ์๋ก ๋์ด์ค๋ ๊ฐ์ด ์ด๋ค Context์ ์ํด์๋๋์ ๋ฐ๋ผ
๋ค๋ฅธ ๋์์ ํ๊ฒ ๋ฉ๋๋ค. Context์ ๋ฌด๊ดํ๊ฒ ์ ์ฐํ ๋์์ ํ ์ ์๋ ๊ฑฐ์ฃ .
Prelude> threeRepeat [1,2,3,4]
[[1,1,1],[2,2,2],[3,3,3],[4,4,4]]
Prelude> threeRepeat (Just 3)
Just [3,3,3]
6. Functor Rule
Functor ํ์
ํด๋์ค์ ์ํ๋ ํ์
๋ค์ ๋ฐ๋์ ๋ค์ ๊ท์น์ ๋ง์กฑํด์ผํฉ๋๋ค.
1. fmap id = id
id๋ ์ธ์๋ก ๋๊ธด ๊ฐ์ ๊ทธ๋ฅ ๊ทธ๋๋ก ๋๋ ค์ฃผ๋ ํจ์์
๋๋ค(id x = x). fmap id๋ Context ๋ด๋ถ์
์ํ๋ ๊ฐ์ ๋ํด id ํจ์๋ฅผ ์ ์ฉํ๋ค๋ ์๋ฏธ์ด๋ฏ๋ก, ๊ทธ๋ฅ ์๋ ๊ฐ์ ๊ทธ๋๋ก ๋๋ ค์ฃผ๋ id์ ๊ฐ์
์ฐจ์ด๊ฐ ์์ด์ผํ ๊ฒ์
๋๋ค.
2. fmap (f . g) = fmap f . fmap g
์ด๋ Context์ ๋ํด ํฉ์ฑํจ์ f . g๋ฅผ ์ ์ฉํ ๊ฒ๊ณผ, g, f๋ฅผ ์์๋๋ก Context ๋ด๋ถ์ mappingํ์
๋ ๊ฒฐ๊ณผ์ ์ฐจ์ด๊ฐ ์์ด์ผํจ์ ๋ปํฉ๋๋ค.
7. Functor Rule
์์ ๊ท์น์ Haskell ์ปดํ์ผ๋ฌ๊ฐ ์์์ ์ก์์ฃผ์ง ์๊ธฐ ๋๋ฌธ์, Functor ํ์
ํด๋์ค์ ์ํ๋
ํ์
์ ๋ง๋ค ๋ ์ค์ค๋ก ์ฃผ์ํด์ ์์ฑํด์ผํฉ๋๋ค.
์ ๋ฐ ๊ท์น์ ์ผํ ๋ถํ์ํ๊ณ ๋ฒ๊ฑฐ๋ก์๋ณด์ผ ์ ์์ง๋ง, ํด๋น ํ์
์ ์ฐ๋ ์
์ฅ์์ fmap์ ๋์์ด
์ด๋ป๊ฒ ๋ ์ง ์์ธกํ ์ ์๊ฒ ํด์ฃผ๋ฉฐ, fmap ํจ์๊ฐ ์ ๋ง๋ก Context ๋ด๋ถ์ ํจ์๋ฅผ mappingํด์ค๋ค๋
๋์ ๊ทธ ์์ฒด๋ง์ ์ํํจ์ ๋ณด์ฅํด์ค๋๋ค. ์ฌ์ฉ์ ์
์ฅ์์ fmap์ ์ธ ๋ ๋ค๋ฅธ ๋ถ๊ฐ์ ์ธ ์ด๋ค ๊ฒฐ๊ณผ๊ฐ
์ ๋ ๋ฐ์ํ์ง ์์ ๊ฒ์์ ๋ฏฟ๊ณ ์ธ ์ ์๋ค๋ ๋ป์ด์ฃ .
8. ์ฐ์ต๋ฌธ์
์๋ ์๋ฃ๊ตฌ์กฐ Tree์ ๋ํ Functor instance๋ฅผ ์์ฑํด๋ด
์๋ค.
data Tree a = Node a [Tree a]
์์ค ์ฝ๋ ํ์ผ์ ์๋ง ์๋์ ๊ฐ์ ํํ๊ฐ ๋๊ฒ ์ฃ .
import Control.Functor
data Tree a = Node a [Tree a]
instance Functor Tree where
fmap ...
9. Applicative Functor
์์์ Functor๋ ์ด๋ค ์ผ๋ฐ์ ์ธ ๊ฐ์ ๋ํ ํจ์ (a->b)์ Context ์์ ์ํ๋ ๊ฐ(f a)์ด ์ฃผ์ด์ก์
๋ ๊ทธ Context ๋ด๋ถ ๊ฐ์ ํจ์๋ฅผ ์ ์ฉ์ํจ ๊ฒฐ๊ณผ (f b)๋ฅผ ๋๋ ค์ค ์ ์๋ ํ์
๋ค์ ์งํฉ์ด๋ผ๊ณ
ํ์ต๋๋ค.
Applicative Functor๋ ์ฌ๊ธฐ์ ํ๋ฐ์ง ๋ ๋์๊ฐ ๊ฐ๋
์
๋๋ค. Haskell์ ์ปค๋ง ๊ฐ๋
์ ์ด์ฉํด์ ๋ค์
์์ ์คํํ์ ๋ ๊ฒฐ๊ณผ๋ ์ด๋ป๊ฒ ๋ ๊น์?
fmap (*) (Just 3)
์ด ๊ฒฐ๊ณผ๋ ๋น์ฐํ Just (*3)์ด ๋ ๊ฒ์
๋๋ค. ์ด๊ฑด Context ์์ ํจ์๊ฐ ๋ค์ด๊ฐ ์๋ ํํ๋ก ๋ณผ
์ ์์ฃ . ์ด ๋ Just (*3)๊ณผ Just 6์ด ์์ ๋ ๊ฒฐ๊ณผ๋ฅผ ๊ณ์ฐํ ์ ์์๊น์? ์ ์ง ๊ฒฐ๊ณผ๋ก Just 18
์ ์ป์ ์ ์์ด์ผํ ๊ฒ ๊ฐ์ง ์๋์? ์ด๋ด ๋ ์ธ ์ ์๋ ํ์
์ด Applicative Functor์ ์ํ๋
ํ์
๋ค์
๋๋ค.
10. Applicative Functor
Applicative Functor๋ ๋ค์๊ณผ ๊ฐ์ด ์ ์๋์ด ์์ต๋๋ค.
class (Functor f) => Applicative f where
pure :: a -> f a
(<*>) :: f (a -> b) -> f a -> f b
Applicative ํ์
ํด๋์ค์ ์ํ๋ ค๋ฉด ์ฐ์ Functor ํ์
ํด๋์ค์ ์ํด์ผํฉ๋๋ค. Applicative๊ฐ ํ
๋ฐ ๋ ๋์๊ฐ ๊ฐ๋
์ด๊ธฐ ๋๋ฌธ์ ์ด์ฐ๋ณด๋ฉด ๋น์ฐํ ์ผ์ด์ฃ .
์ฐ์ pure ํจ์๋ถํฐ ์ดํด๋ด
์๋ค. pure ํจ์๋ ๊ทธ๋ฅ ๊ฐ์ด ์ฃผ์ด์ ธ์์ ๋ ์ด ๊ฐ์ ๋จ์ํ ํด๋น
Context ๋ด๋ถ๋ก ์ง์ด๋ฃ๋ ์ญํ ์ ํฉ๋๋ค. Maybe context์ ๋ํด pure 3 = Just 3 ์ด ๋ ๊ฑฐ๋ผ๊ณ
์๊ฐํ ์ ์๊ฒ ์ฃ .
Applicative Functor๋ ์ฌ์ฉํ๋ ค๋ฉด Control.Applicative ๋ชจ๋์ ์ํฌํธํด์ผํฉ๋๋ค
(import Control.Applicative).
11. Applicative Functor
๋ค์์ Applicative Functor์ ํต์ฌ ๊ธฐ๋ฅ์ ํ๋ ํจ์์ธ <*> ์
๋๋ค. ์ด ํจ์๋ Context ๋ด๋ถ์
์๋ ํจ์๋ฅผ ๊บผ๋ด์, ๊ทธ ํจ์๋ฅผ Context ๋ด๋ถ์ ๊ฐ์ ์ ์ฉ์ํจ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํฉ๋๋ค. ์๋ฅผ ๋ค์ด Maybe
ํ์
์ ๋ํด Applicative ํ์
ํด๋์ค๋ ๋ค์๊ณผ ๊ฐ์ด ์ ์๋์ด ์์ต๋๋ค.
instance Applicative Maybe where
pure = Just
Nothing <*> _ = Nothing
(Just f) <*> something = fmap f something
context ์์ ์ด๋ค ํจ์๋ ์กด์ฌํ์ง ์๋๋ค๋ฉด Nothing, ๊ทธ๋ ์ง ์๋ค๋ฉด ๊ทธ ํจ์๋ฅผ Context ์์์
๊บผ๋ด fmap์ ํธ์ถํ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ์ฃ .
12. Applicative Functor
Applicative Functor์ ํจ์ pure์ <*>๋ฅผ ์ด๋ป๊ฒ ์ฐ๋์ง ์์ ๋ฅผ ์ดํด๋ด
์๋ค.
Prelude> Just (+3) <*> Just 9
Just 12
Prelude> pure (+3) <*> Just 10
Just 13
Prelude> Just (++"hahaha") <*> Nothing
Nothing
Prelude> Nothing <*> Just "Test"
Nothing
13. Applicative Functor
Haskell์ ๋ชจ๋ ํจ์๊ฐ ๋ค ์ปค๋ง์ด ๋๋ค๋ ํน์ง ๋๋ถ์ ์ฌ๋ฌ ๊ฐ์ ์ธ์๋ฅผ ๊ฐ์ง ํจ์์ ๋ํด์๋ <*>
ํจ์๋ฅผ ์ ์ฉํ ์ ์์ต๋๋ค. <*> ํจ์๋ left-associativeํ ํจ์๊ธฐ ๋๋ฌธ์ ์ผ์ชฝ๋ถํฐ ์ฐจ๋ก๋๋ก ๊ฒฐ๊ณผ๋ฅผ
๊ณ์ฐํ๊ฒ ๋์ฃ .
Prelude> pure (+) <*> Just 3 <*> Just 5
Just 8
Prelude> pure (+) <*> Just 3 <*> Nothing
Nothing
Prelude> pure (+) <*> Nothing <*> Just 5
Nothing
14. Applicative Functor
Applicative Functor๊ฐ ์ง์ผ์ผํ๋ ๊ท์น(Functor๊ฐ ์ง์ผ์ผํ ๊ท์น๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก Applicative
Functor ์ญ์ ๋ง์กฑํด์ผํ๋ ๊ท์น์ด ์์ต๋๋ค. ์ดํ ์ค๋ช
)์ ์ํด, pure f <*> x ๋ fmap f x์ ํญ์
๋์ผํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด ํน์ง์ ์ด์ฉํด Applicative Functor๋ฅผ ์ข ๋ ๊ฐ๋
์ฑ ์๋ ๋ฐฉ์์ผ๋ก ์ฌ์ฉํ ์
์์ต๋๋ค.
(<$>) :: (Functor f) => (a -> b) -> f a -> f b
f <$> x = fmap f x
<$>๋ ๋จ์ํ fmap์ ์ค์ ์ฐ์ฐ์์ ํํ๋ก ํํํ ํจ์์
๋๋ค. ์ด ํจ์๋ฅผ ์ด์ฉํ๋ฉด pure f <*>
x <*> y <*> ... ํํ์ ์์ f <$> x <*> y <*> ... ํํ๋ก ๋ฐ๊ฟ์ธ ์ ์๊ณ , ์ด๋ ์ค๊ฐ์
<$>, <*>๋ฅผ ์ ์ธํ๊ณ ๋ณด๋ฉด ์ผ๋ฐ์ ์ธ ํจ์๋ฅผ ๊ทธ๋ฅ ์ฐ๋ ๊ฒ๊ณผ ์์ ํ ๋์ผํด ๋ณด์
๋๋ค.
15. Applicative Functor
List ์ญ์ Applicative Functor์
๋๋ค. Applicative Functor๋ก์์ List๋ ๋น๊ฒฐ์ ์ฑ์ด๋ผ๋
Context๋ฅผ ๊ฐ์ง๊ฒ ๋ฉ๋๋ค.
instance Applicative [] where
pure x = [x]
fs <*> xs = [f x | f <- fs, x <- xs]
ํจ์ list์ ์์ list์ ๋ํด, ๋ชจ๋ ์ข
๋ฅ์ ํจ์ ์ ์ฉ ์กฐํฉ์ ๋ค ์ํํ ๊ฒฐ๊ณผ๋ฅผ ๋ฆฌ์คํธ์ ๋ด๊ณ ์์ฃ . ์ด๋
์ด๋ค ํจ์๋ฅผ ์ด๋ค ์์์ ๋ํด ์ ์ฉํ ์ง ๋ชจ๋ฅด๋, ๋น๊ฒฐ์ ์ ์ธ ์ฐ์ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์๋ฏธํฉ๋๋ค.
16. Applicative Functor
์ฌ๋ฌ ๊ฐ์ง ์์ ๋ฅผ ์ดํด๋ด
์๋ค.
Prelude> [(*0),(+100),(^2)] <*> [1, 2, 3]
[0, 0, 0, 101, 102, 103, 1, 4, 9]
Prelude> [(+), (*)] <*> [1, 2] <*> [3,4]
[4, 5, 5, 6, 3, 4, 6, 8]
Prelude> (++) <$> ["ha","heh","hmm"] <*> ["?","!","."]
["ha?", "ha!", "ha.", "heh?", "heh!", "heh.", "hmm?", "hmm!", "hmm."]
Prelude> (++) <$> (Just "ha") <*> (Just "!")
Just "ha!"
Applicative Functor๋ ์์ ๊ฐ์ด ์ด๋ฏธ ์ด๋ค Context ๋ด์ ๋ค์ด๊ฐ ์๋ ๊ฐ๋ค์ ๋ํด ํจ์๋ฅผ
ํธ์ถํ๊ณ ์ถ์ ๋ ์ ์ฉํ๊ฒ ์ฌ์ฉํ ์ ์์ต๋๋ค.
17. Applicative Functor
์์์ ์ธ๊ธํ๋ฏ Applicative Functor ์ญ์ Functor์ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฐ๋์ ์ง์ผ์ผํ๋ ๊ท์น์ด
์์ต๋๋ค. ๋ค ์ค๋ช
ํ์๋ฉด ๋ด์ฉ์ด ๋ณต์กํ๊ณ ๊ธฐ๋ ์ค๋ช
์ ์๋ตํ๊ณ , ๊ท์น๋ง ์๊ฐํ๊ฒ ์ต๋๋ค. ์ดํ
Applicative Functor๋ฅผ ๊ตฌํํด์ผํ ์ผ์ด ์๊ธด๋ค๋ฉด ๊ทธ ๋ ๊น์ด ์๊ฒ ๊ณต๋ถํด๋ณด์๋๊ฒ ์ข์ ๊ฒ ๊ฐ๋ค์.
1. pure id <*> v = v
2. pure (.) <*> u <*> v <*> w = u <*> (v <*> w)
3. pure f <*> pure x = pure (f x)
4. u <*> pure y = pure ($ y) <*> u