์‹ค์ œ Functor๋Š” ๋ฌด์—‡์„ ์˜๋ฏธํ•˜๋Š”๊ฐ€?

Functor

์นดํ…Œ๊ณ ๋ฆฌ ์‚ฌ์ด์—์„œ์˜ ์‚ฌ์ƒ(morphisms)

  • ๋™์งˆ์˜ ๋Œ€์ƒ๋“ค์„ ๊ทœ์ •ํ•˜๋ฉด, ๊ทธ ์‚ฌ์ด๋ฅผ ๋น„๊ตํ•˜๊ฑฐ๋‚˜ ๋Œ€์‘ํ•˜๊ธฐ ์œ„ํ•œ ์ˆ˜๋‹จ๋„ ํ•„์š”ํ•˜๋‹ค.
  • ์ง‘ํ•ฉ์˜ ๊ฒฝ์šฐ ์ง‘ํ•ฉ ์‚ฌ์ด์˜ ํ•จ์ˆ˜๊ฐ€ ๊ทธ๊ฒƒ์ด๋‹ค.
  • ๊ทธ๋ž˜์„œ ๋Œ€์ƒ๋“ค ์‚ฌ์ด์—๋Š” ์‚ฌ์ƒ(morphisms)๊ฐ€ ์žˆ์„ ์ˆ˜ ๋ฐ–์— ์—†๋‹ค.
  • ์นดํ…Œ๊ณ ๋ฆฌ ์ด๋ก ๋Š” ๊ทธ ๋Œ€์ƒ๋“ค ์‚ฌ์ด์˜ ์‚ฌ์ƒ์„ ๊ฐ€์ง€๋Š” ์ฒด๊ณ„ ์ž์ฒด๋ฅผ ๋‹ค์‹œ ๋Œ€์ƒ์œผ๋กœ ํ•˜๋Š” ๋ฉ”ํƒ€์ˆ˜ํ•™ ์ด๋ก ์ด๋‹ค.
  • ์ด๋ ‡๊ฒŒ ํ•ด์„œ ๊ทธ๋Ÿฌํ•œ ๊ตฌ์กฐ๋ฅผ ๊ฐ€์ง„ ์ฒด๊ณ„๋“ค์˜ ์ผ๋ฐ˜์ ์ธ ์›๋ฆฌ๋ฅผ ๋„์ถœํ•˜๋Š” ๊ฒƒ์„ ๋ชฉ์ ์œผ๋กœ ํ•œ๋‹ค.

์นดํ…Œ๊ณ ๋ฆฌ ์ด๋ก ์—์„œ๋Š” ์™ผ์ชฝ์˜ ์ง‘ํ•ฉ/ํ•จ์ˆ˜์˜ ์ฒด๊ณ„ ์ž์ฒด๋ฅผ ์˜ค๋ฅธ์ชฝ ์ฒ˜๋Ÿผ ๊ทœ์ •ํ•˜๊ณ , ์ด๋ฅผ โ€œ๋Œ€์ƒโ€์œผ๋กœ ๋‹ค๋ฃฌ๋‹ค.

์ •์˜

๋‹ค์Œ์„ ๋ณด์กดํ•˜๋ฉฐ ํ•œ ์นดํ…Œ๊ณ ๋ฆฌ์˜ ๋Œ€์ƒ๊ณผ ์‚ฌ์ƒ์„, ๋‹ค๋ฅธ ์นดํ…Œ๊ณ ๋ฆฌ์˜ ๋Œ€์ƒ๊ณผ ์‚ฌ์ƒ์— ๊ฐ๊ฐ ๋Œ€์‘์‹œํ‚ค๋Š” ๊ด€๊ณ„

  1. ๋Œ€์ƒ๊ณผ ์‚ฌ์ƒ์˜ ๊ตฌ์กฐ๋ฅผ ๋ณด์กดํ•œ๋‹ค.
  2. ํ•ญ๋“ฑ ์‚ฌ์ƒ์„ ๋ณด์กดํ•œ๋‹ค.
    • f๊ฐ€ ํ•ญ๋“ฑ์‚ฌ์ƒ์ผ ๊ฒฝ์šฐ ๋ณ€ํ™˜ํ–ˆ์„ ๋•Œ F(f)๋„ ํ•ญ๋“ฑ ์‚ฌ์ƒ์ด์–ด์•ผ ํ•œ๋‹ค.
  3. ์‚ฌ์ƒ์˜ ํ•ฉ์„ฑ๊ด€๊ณ„๋ฅผ ๋ณด์กดํ•œ๋‹ค.
    • C์— ๋ผ ํ• ๊ฒฝ์šฐ, ๊ฐ€ ๋˜์–ด์•ผ ํ•œ๋‹ค.

ํ•จ์ž๋Š” ์‚ฌ์ƒ์ธ๊ฐ€?

  • ํ•จ์ž๋Š” ๋Œ€์ƒ์ด ์นดํ…Œ๊ณ ๋ฆฌ์ผ ๋ฟ, ์‚ฌ์ƒ์ž„์€ ๋™์ผํ•˜๋‹ค.
  • ๊ทธ๋ฆฌ๊ณ  ํ•จ์ž๋Š” ํ•ฉ์„ฑ ๊ฐ€๋Šฅํ•˜๋‹ค.
  • ํ•ญ๋“ฑ ๋ณ€ํ™˜๋„ ์žˆ๋‹ค. ์นดํ…Œ๊ณ ๋ฆฌ๋ฅผ ์ž์‹ ์œผ๋กœ ์„ค์ •๋งŒ ํ•˜๋ฉด ๋œ๋‹ค.
  • ๊ฒฐ๊ตญ ํ•จ์ž๋Š” ์™„๋ฒฝํžˆ ์‚ฌ์ƒ์˜ ์กฐ๊ฑด์„ ๋งŒ์กฑํ•œ๋‹ค.
  • ์ด๋Š” ๊ณง ์ด์ „ ์žฅ์—์„œ ์•Œ์•„๋ณธ ์‚ฌ์ƒ์˜ ํŠน์ง•๋“ค์€ ํ•จ์ž์— ๋ชจ๋‘ ์ ์šฉ๋œ๋‹ค.
  • ํ•จ์ž๋„ Isomorphism(๋™ํ˜• ์‚ฌ์ƒ)์ด๊ฑฐ๋‚˜ monomorphism์ผ ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์ด๋‹ค.
  • ํŠนํžˆ Isomorphism์— ํ•ด๋‹นํ•˜๋Š” ํ•จ์ž๋“ค์ด ์ด๋ก ์ ์œผ๋กœ ์ค‘์š”ํ•˜๋‹ค.
    • ์—ญ์‚ฌ์ƒ์ด ์กด์žฌํ•˜๋Š” ํ•จ์ž๋ฅผ ๋งํ•จ

Endofunctor

  • ํ”„๋กœ๊ทธ๋ž˜๋จธ์—๊ฒŒ ๊ฐ€์žฅ ์ค‘์š”ํ•œ ํ•จ์ž๋Š” ์ •์˜์—ญ๊ณผ ๊ณต์—ญ์ด ๊ฐ™์€, ์ฆ‰, C์—์„œ C๋กœ ๊ฐ€๋Š” ๊ฒƒ๋“ค์ด๋‹ค.
  • ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ Functor๋Š” ๋ฐ”๋กœ ํƒ€์ž…(Type) ์นดํ…Œ๊ณ ๋ฆฌ์˜ ์ž๊ธฐ ํ•จ์ž๋ฅผ ์˜๋ฏธํ•œ๋‹ค.
  • ์—ฌ๊ธฐ์„œ Type์€ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ์‚ฌ์šฉํ•˜๋Š” Type์„ ์˜๋ฏธํ•œ๋‹ค.
  • T-> F<T>, U -> F<U>, f -> lift(f)์˜ ํ˜•ํƒœ๋กœ ๋ณ€ํ™˜ ๋˜๋Š” ๊ฒƒ์ด๋‹ค.

ํ”„๋กœ๊ทธ๋ž˜๋ฐ์— ์‚ฌ์šฉ๋˜๋Š” ๋‹ค๋ฅธ ํ•จ์ž

  • ๊ทธ๋ ‡์ง€๋งŒ ๋ชจ๋“  ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ์‚ฌ์šฉ๋˜๋Š” ๋ชจ๋“  ํ•จ์ž๊ฐ€ ์ž๊ธฐ ํ•จ์ž์ธ ๊ฒƒ์€ ์•„๋‹ˆ๋‹ค.

Evaluator

Evaluator<T>: T -> Double

  • ์œ„์™€ ๊ฐ™์€ ํ˜•ํƒœ์˜ 01. Type Constructor (Generic function)๋ฅผ ์ƒ๊ฐํ•ด๋ณด์ž.
  • endo functor์ธ์ง€ ํ™•์ธํ•ด๋ณด์ž.
  • ์ž„์˜์˜ Tํƒ€์ž…์„ Evaluator<T>๋กœ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š”๊ฐ€? : O
  • ์ž„์˜์˜ Uํƒ€์ž…์„ Evaluator<U>๋กœ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š”๊ฐ€? : O
  • liftํ•จ์ˆ˜๋ฅผ ์ •์˜ํ•  ์ˆ˜ ์žˆ๋Š”๊ฐ€?: X
func lift<T, U>(_ f: @escaping T -> U) -> (Evaluator<T> -> Evaluator<U>) {
	{  et in
		// ???		
	}
}
 
func lift<T, U>(_ f: @escaping T -> U) -> (T? -> U?) {
	{  op in
		switch op {
		case .some(let p):
			return .some(f(p))
		case .none:
			return .none
		}
	}
}
  • ์ด๋ ‡๊ฒŒ ์ •์˜๊ฐ€ ๋ถˆ๊ฐ€๋Šฅํ•˜๋‹ค.
  • ๊ทธ๋Ÿฐ๋ฐ ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ์ •์˜๊ฐ€ ๊ฐ€๋Šฅํ•˜๋‹ค.
func antiLift<T, U>(_ f: @escaping U -> T) -> (Evaluator<T> -> Evaluator<U>) {
	{  et in
		et.transform(f) // T ๋ณ€์ˆ˜์— ์ ‘๊ทผํ•˜์—ฌ ๊ฐ’์„ U๋กœ ๋ณ€ํ™˜ํ•˜๋Š” ๊ฒƒ์„ ํ‘œํ˜„ํ•จ
	}
}
  • `f: U โ†’ T
  • et: T -> Double
  • et o f: U -> Double == Evaluator<U>
  • ์ด์™€ ๊ฐ™์ด ์ฃผ์–ด์ง€๋Š” ํ•จ์ˆ˜์— ๋”ฐ๋ผ lift๊ฐ€ ๊ฐ€๋Šฅํ•œ ๊ฒฝ์šฐ๋„ ์žˆ๋‹ค.
  • ์ด๋Š” ์™„์ „ํžˆ โ€œํƒ€์ž… ์นดํ…Œ๊ณ ๋ฆฌ์˜ ์ž๊ธฐํ•จ์žโ€๋Š” ์•„๋‹ˆ์ง€๋งŒ, ๋‹ค๋ฅธ ์˜๋ฏธ๊ฐ€ ์žˆ๋‹ค.
  • Evaluator๋Š” Type์˜ Opposite Category์ด๋‹ค. (Type_op โ‡’ Type Functor)

Opposite Category

  • Type_op(Type opposite): Type์—์„œ ์‚ฌ์ƒ์˜ ๋ฐฉํ–ฅ๋งŒ ๋ฐ˜๋Œ€๋กœ ํ•œ ์นดํ…Œ๊ณ ๋ฆฌ
  • ์นดํ…Œ๊ณ ๋ฆฌ๊ฐ€ ๋˜๊ธฐ ์œ„ํ•œ ์กฐ๊ฑด์€ ํ•ญ๋“ฑ ์‚ฌ์ƒ ์กด์žฌ, ํ•ฉ์„ฑ ๊ฐ€๋Šฅ๋ฐ–์— ์—†๋‹ค.
  • ๊ทธ๋ ‡๊ธฐ ๋•Œ๋ฌธ์— Type Opposite์€ ์นดํ…Œ๊ณ ๋ฆฌ์˜ ์กฐ๊ฑด์„ ๋งŒ์กฑํ•œ๋‹ค.
  • Opposite Category์—์„œ๋Š” U->T ํ•จ์ˆ˜๊ฐ€ T->U๋กœ ๊ฐ€๋Š” ์‚ฌ์ƒ์œผ๋กœ ์ทจ๊ธ‰๋œ๋‹ค.

contravariant functor

  • Evaluator๋Š” ์ด์™€ ๊ฐ™์ด ์ •๋ฆฌํ•  ์ˆ˜ ์žˆ๋‹ค.
  • ์ด๋Ÿฐ ์‹์œผ๋กœ C_op -> D์œผ๋กœ ๊ฐ€๋Š” ํ•จ์ž๋ฅผ C -> D๋กœ ๊ฐ€๋Š” contravariant ํ•จ์ž, ๋ฐ˜๋ณ€ ํ•จ์ž๋ผ๊ณ  ํ•œ๋‹ค.
  • ์ฆ‰, Evaluator๋Š” Type์— ๋Œ€ํ•œ Covariant endofunctor์ด๋‹ค.
    • Opposite Type Category์—์„œ Type Category๋กœ ๊ฐ€๋Š” ํ•จ์ž

Pair

Pair<T, U>: T, U๋ฅผ ์ฃผ๋ฉด Tuple์„ ๋งŒ๋“ค์–ด์คŒ

  • ์ผ๋ถ€ 01. Type Constructor๋Š” ๋‘ ๊ฐœ ์ด์ƒ์˜ ํƒ€์ž… ์ธ์ˆ˜๋ฅผ ์š”๊ตฌํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ์žˆ๋‹ค.
func lift<U, V>(_ f: @escaping U -> V) -> (Pair<T, U> -> Pair<T, V>) {
	{ pairTU in
		(pairTU.first, f(pairTU.second))
	}
}
 
func lift<U, V>(_ f: @escaping U -> V) -> (Pair<U, T> -> Pair<V, T>) {
	{ pairUT in
		(f(pairUT.first), pairUT.second)
	}
}
  • T๋‚˜ U๊ฐ€ ํ•˜๋‚˜์”ฉ ๊ณ ์ •๋œ ์ƒํ™ฉ์—์„œ lift ํ•จ์ˆ˜๋ฅผ ์ •์˜ํ•˜๋Š” ๊ฒƒ์€ ๊ฐ„๋‹จํ•˜๋‹ค.
    • ์ด๋Š” ๊ณง Pair๊ฐ€ ์ž๊ธฐ ํ•จ์ž์ž„์„ ๋‚˜ํƒ€๋‚ด๋Š” ๊ฒƒ๊ณผ ๋™์น˜์ด๋‹ค.
    • U -> Pair<T, U>, V -> Pair<T, V>๋กœ ๋งŒ๋“œ๋Š” ๊ฑด ๋‹น์—ฐํ•˜๋‹ˆ ์‚ฌ์ƒ์— ๋Œ€ํ•œ ๋ณ€ํ™˜๋งŒ ํ™•์ธํ•˜๋ฉด ๋œ๋‹ค.
  • ๊ทธ๋Ÿผ Pair ์ž์ฒด๋Š” ์–ด๋–จ๊นŒ?

Product Category

  • ์ˆœ์„œ์Œ์„ ๋Œ€์ƒ์œผ๋กœ ํ•˜๋Š” ์นดํ…Œ๊ณ ๋ฆฌ๋ฅผ ์ •์˜ํ•ด๋ณด์ž.
  • C, D ์นดํ…Œ๊ณ ๋ฆฌ๊ฐ€ ์žˆ์„ ๋•Œ, ๊ฐ๊ฐ์— ๋Œ€์‘๋˜๋Š” ๋Œ€์ƒ์„ ์ˆœ์„œ์Œ์œผ๋กœ ๋งŒ๋“ค ์ˆ˜ ์žˆ์„ ๊ฒƒ์ด๋‹ค.
  • ์ด๋ ‡๊ฒŒ ๋Œ€์ƒ์˜ ์ˆœ์„œ์Œ์„ ๋‹ค์‹œ ๋Œ€์ƒ์œผ๋กœ, ์‚ฌ์ƒ์˜ ์ˆœ์„œ์Œ์„ ๋‹ค์‹œ ์‚ฌ์ƒ์œผ๋กœ ํ•˜๋Š” ์นดํ…Œ๊ณ ๋ฆฌ๋ฅผ Product ์นดํ…Œ๊ณ ๋ฆฌ๋ผ ํ•œ๋‹ค.

  • Pair๋Š” Type x Type์—์„œ Type์œผ๋กœ ๊ฐ€๋Š” ํ•จ์ž์ด๋‹ค.
  • f: X1 -> Y1, g: X2 -> Y2 ํ•จ์ˆ˜์˜ ์ˆœ์„œ์Œ์ด ์ฃผ์–ด์ง€๋ฉด, Pair<X1, X2> -> Pair<Y1, Y2>์˜ ํ•จ์ˆ˜๋„ ์‰ฝ๊ฒŒ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค.

๋‘๊ฐœ์˜ ํƒ€์ž… ์ธ์ˆ˜๋ฅผ ๊ฐ€์ง„ Type Constructor

์ผ๋ฐ˜์ ์œผ๋กœ ๋‘๊ฐœ์˜ ํƒ€์ž…์ธ ์ˆ˜๋ฅผ ๊ฐ€์ง„ 01. Type Constructor๋Š”, ๋‹ค์Œ์„ ๋งŒ์กฑํ•  ๊ฒฝ์šฐ ํ•ญ์ƒ Type x Type -> Type ํ•จ์ž๊ฐ€ ๋œ๋‹ค.

  1. F<T, >๊ฐ€ Type -> Type Functor์ด๋‹ค.
  2. F<, T>๊ฐ€ Type -> Type Functor์ด๋‹ค.

์ด๋Ÿฐ ๊ฒฝ์šฐ๋Š” ์–ด๋–จ๊นŒ?

๋‘๊ฐœ์˜ ์ธ์ž๋ฅผ ๊ฐ–๋Š” Functor F๋Š” ์•„๋ž˜๋ฅผ ๋งŒ์กฑํ•œ๋‹ค.

  1. F<T, >๊ฐ€ Type_op -> Type Functor์ด๋‹ค.
  2. F<, T>๊ฐ€ Type -> Type Functor์ด๋‹ค.

๋‹จ์ˆœํ•˜๋‹ค. F๋Š” Type_op x Type -> Type ํ•จ์ž๊ฐ€ ๋œ๋‹ค. ํ•จ์ˆ˜ ํƒ€์ž…Function<T, U> == T -> U์„ ๋งŒ๋“œ๋Š” 01. Type Constructor๊ฐ€ ๋Œ€ํ‘œ์ ์ด๋‹ค.

์–ด์–ด.. ์—ฌ๊ธฐ์„œ ๋จธ๋ฆฌ๊ฐ€ ์•ˆ๋Œ์•„๊ฐ€๋Š”๋ฐ ๊ฑฑ์ •๋ง์ž.

์ •๋ฆฌ

  • ์œ„์—์„œ ์•Œ์•„๋ณธ Functor๋Š” ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ์˜ Functor์— ํฌํ•จ๋˜์ง€๋Š” ์•Š๋Š”๋‹ค.
  • ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ์˜ Functor๋Š” Type -> Type, ์ฆ‰ ์ž๊ธฐ ํ•จ์ž์—์„œ ๊ทธ์น˜๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.
  • ์ˆ˜ํ•™์—์„œ์˜ Functor๋Š” ๋งŽ์€ ๊ฒƒ์„ ํฌํ•จํ•˜๋Š” ์ผ๋ฐ˜์ ์ธ ๊ฐœ๋…์ด๋‹ค.
  • ์ ๋‹นํžˆ ์ดํ•ดํ–ˆ๋‹ค๋ฉด ๋„˜์–ด๊ฐ€๋„ ๋ฌด๋ฐฉํ•˜๋‹ค.

Reference