Haskell
Study
8. Functor
Context
Haskell์˜ ํƒ€์ž… ์ƒ์„ฑ์ž๋Š” ์ผ์ข…์˜ ๋ฌธ๋งฅ(Context)๊ณผ ๊ฐ™์ด ์ทจ๊ธ‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด Maybe ํƒ€์ž…
์ƒ์„ฑ์ž๋Š” Maybe ๋ผ๋Š” ๋ฌธ๋งฅ๊ณผ ๊ทธ ๋ฌธ๋งฅ ์†์˜ ํƒ€์ž…(Int, Char ๋“ฑ)์œผ๋กœ ์ƒ๊ฐํ•  ์ˆ˜ ์žˆ์ฃ .
Maybe
Int
Maybe Int์—์„œ Maybe๋Š” ํ•ด๋‹น ํƒ€์ž…์— ๋Œ€ํ•œ Context์ž…๋‹ˆ๋‹ค. Maybe๋Š” ๋ถˆํ™•์‹ค์„ฑ- ์ฆ‰, ๊ฒฐ๊ณผ๊ฐ€
์กด์žฌํ•  ์ˆ˜๋„(Just Int) ๊ทธ๋ ‡์ง€ ์•Š์„์ˆ˜๋„(Nothing)์žˆ๋‹ค๋ผ๋Š” ๋ถ€๊ฐ€์ ์ธ ๋ฌธ๋งฅ ์ •๋ณด๋ฅผ ๊ฐ€์ง‘๋‹ˆ๋‹ค.
ํƒ€์ž… ์ƒ์„ฑ์ž๋ฅผ ์ด๋Ÿฐ ๋ฌธ๋งฅ์˜ ๊ด€์ ์—์„œ ๋ดค์„ ๋•Œ ํŠน์ • ํƒ€์ž… ์ƒ์„ฑ์ž์— ๋Œ€ํ•œ ํƒ€์ž… ํด๋ž˜์Šค๋Š” ๊ทธ ๋ฌธ๋งฅ ๊ณ ์œ ์˜
ํ–‰๋™์„ ์ •์˜ํ•˜๋Š” ๊ฒƒ์œผ๋กœ ์ƒ๊ฐํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
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 ๋‚ด๋ถ€์— ์†ํ•œ ์›์†Œ ์ „์ฒด์— ๋Œ€ํ•ด ํ•ด๋‹น ํ•จ์ˆ˜๋ฅผ ์ ์šฉ์‹œํ‚ค๋Š” ๊ฒƒ์ด์ฃ .
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)์— ํ•จ์ˆ˜๋ฅผ ์ ์šฉํ•œ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.
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]
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ํ–ˆ์„
๋•Œ ๊ฒฐ๊ณผ์˜ ์ฐจ์ด๊ฐ€ ์—†์–ด์•ผํ•จ์„ ๋œปํ•ฉ๋‹ˆ๋‹ค.
Functor Rule
์•ž์˜ ๊ทœ์น™์€ Haskell ์ปดํŒŒ์ผ๋Ÿฌ๊ฐ€ ์•Œ์•„์„œ ์žก์•„์ฃผ์ง€ ์•Š๊ธฐ ๋•Œ๋ฌธ์—, Functor ํƒ€์ž… ํด๋ž˜์Šค์— ์†ํ•˜๋Š”
ํƒ€์ž…์„ ๋งŒ๋“ค ๋•Œ ์Šค์Šค๋กœ ์ฃผ์˜ํ•ด์„œ ์ž‘์„ฑํ•ด์•ผํ•ฉ๋‹ˆ๋‹ค.
์ €๋Ÿฐ ๊ทœ์น™์€ ์–ผํ• ๋ถˆํ•„์š”ํ•˜๊ณ  ๋ฒˆ๊ฑฐ๋กœ์›Œ๋ณด์ผ ์ˆ˜ ์žˆ์ง€๋งŒ, ํ•ด๋‹น ํƒ€์ž…์„ ์“ฐ๋Š” ์ž…์žฅ์—์„œ fmap์˜ ๋™์ž‘์ด
์–ด๋–ป๊ฒŒ ๋ ์ง€ ์˜ˆ์ธกํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•ด์ฃผ๋ฉฐ, fmap ํ•จ์ˆ˜๊ฐ€ ์ •๋ง๋กœ Context ๋‚ด๋ถ€์— ํ•จ์ˆ˜๋ฅผ mappingํ•ด์ค€๋‹ค๋Š”
๋™์ž‘ ๊ทธ ์ž์ฒด๋งŒ์„ ์ˆ˜ํ–‰ํ•จ์„ ๋ณด์žฅํ•ด์ค๋‹ˆ๋‹ค. ์‚ฌ์šฉ์ž ์ž…์žฅ์—์„œ fmap์„ ์“ธ ๋•Œ ๋‹ค๋ฅธ ๋ถ€๊ฐ€์ ์ธ ์–ด๋–ค ๊ฒฐ๊ณผ๊ฐ€
์ ˆ๋Œ€ ๋ฐœ์ƒํ•˜์ง€ ์•Š์„ ๊ฒƒ์ž„์„ ๋ฏฟ๊ณ  ์“ธ ์ˆ˜ ์žˆ๋‹ค๋Š” ๋œป์ด์ฃ .
์—ฐ์Šต๋ฌธ์ œ
์•„๋ž˜ ์ž๋ฃŒ๊ตฌ์กฐ 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 ...
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์— ์†ํ•˜๋Š”
ํƒ€์ž…๋“ค์ž…๋‹ˆ๋‹ค.
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).
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์„ ํ˜ธ์ถœํ•œ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜ํ•˜์ฃ .
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
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
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 <*> ... ํ˜•ํƒœ๋กœ ๋ฐ”๊ฟ”์“ธ ์ˆ˜ ์žˆ๊ณ , ์ด๋Š” ์ค‘๊ฐ„์˜
<$>, <*>๋ฅผ ์ œ์™ธํ•˜๊ณ  ๋ณด๋ฉด ์ผ๋ฐ˜์ ์ธ ํ•จ์ˆ˜๋ฅผ ๊ทธ๋ƒฅ ์“ฐ๋Š” ๊ฒƒ๊ณผ ์™„์ „ํžˆ ๋™์ผํ•ด ๋ณด์ž…๋‹ˆ๋‹ค.
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์— ๋Œ€ํ•ด, ๋ชจ๋“  ์ข…๋ฅ˜์˜ ํ•จ์ˆ˜ ์ ์šฉ ์กฐํ•ฉ์„ ๋‹ค ์ˆ˜ํ–‰ํ•œ ๊ฒฐ๊ณผ๋ฅผ ๋ฆฌ์ŠคํŠธ์— ๋‹ด๊ณ  ์žˆ์ฃ . ์ด๋Š”
์–ด๋–ค ํ•จ์ˆ˜๋ฅผ ์–ด๋–ค ์›์†Œ์— ๋Œ€ํ•ด ์ ์šฉํ• ์ง€ ๋ชจ๋ฅด๋Š”, ๋น„๊ฒฐ์ •์ ์ธ ์—ฐ์‚ฐ์˜ ๊ฒฐ๊ณผ๋ฅผ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค.
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 ๋‚ด์— ๋“ค์–ด๊ฐ€ ์žˆ๋Š” ๊ฐ’๋“ค์— ๋Œ€ํ•ด ํ•จ์ˆ˜๋ฅผ
ํ˜ธ์ถœํ•˜๊ณ  ์‹ถ์„ ๋•Œ ์œ ์šฉํ•˜๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.
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