[oop] 평범한 영어 모나드? (FP 배경이없는 OOP 프로그래머의 경우)

업데이트 :이 질문은 상당히 긴 블로그 시리즈의 주제였습니다.이 기사는 Monads 에서 읽을 수 있습니다 . 훌륭한 질문에 감사드립니다!

OOP 프로그래머가 (기능적 프로그래밍 배경없이) 이해한다는 관점에서 모나드는 무엇입니까?

모나드는 인 유형의 “증폭” 특정 규칙을 따르는 및 제공된 특정 작업을 갖는다 .

먼저, “타입 증폭기”란 무엇입니까? 그것은 당신이 타입을 가져 와서 더 특별한 타입으로 바꿀 수있는 시스템을 의미합니다. 예를 들어 C #에서는을 고려하십시오 Nullable<T>. 이것은 유형의 증폭기입니다. 예를 들어 유형을 가져 와서 해당 유형 int에 새로운 기능을 추가 할 수 있습니다. 즉 이전에는 불가능했을 때 null이 될 수 있습니다.

두 번째 예로,을 고려하십시오 IEnumerable<T>. 유형의 증폭기입니다. 즉, 유형을 가져 와서 해당 유형 string에 새로운 기능을 추가 할 수 있습니다. 즉, 이제는 여러 개의 단일 문자열에서 일련의 문자열을 만들 수 있습니다.

“확실한 규칙”은 무엇입니까? 간단히 말해서, 기본 유형의 기능이 정상적인 유형의 기능 구성 규칙을 따르도록 증폭 된 유형에서 작동하는 현명한 방법이 있습니다. 예를 들어 정수에 함수가 있다면

int M(int x) { return x + N(x * 2); }

그러면 해당 기능을 Nullable<int>통해 모든 연산자와 호출이 이전과 같은 방식으로 함께 작동 할 수 있습니다.

(이것은 엄청나게 모호하고 부정확합니다. 기능 구성에 대한 지식에 대해서는 아무 것도 가정하지 않은 설명을 요청했습니다.)

“작업”은 무엇입니까?

1. 일반 유형에서 값을 가져와 동등한 모나드 값을 생성하는 “단위”연산 (혼란 적으로 “리턴”연산이라고도 함)이 있습니다. 본질적으로 이것은 증폭되지 않은 유형의 값을 가져 와서 증폭 된 유형의 값으로 바꾸는 방법을 제공합니다. OO 언어의 생성자로 구현 될 수 있습니다.

2. 모나드 값과 값을 변환 할 수있는 함수를 가져 와서 새 모나드 값을 반환하는 “바인드”연산이 있습니다. 바인드는 모나드의 의미를 정의하는 핵심 작업입니다. 이를 통해 증폭되지 않은 유형의 연산을 증폭 된 유형의 연산으로 변환 할 수 있으며, 이는 앞에서 언급 한 기능 구성 규칙을 따릅니다.

3. 증폭되지 않은 유형을 증폭 된 유형에서 다시 가져 오는 방법이 종종 있습니다. 엄밀히 말하면이 작업에는 모나드가 필요하지 않습니다. ( comonad 를 원한다면 필요하지만 이 기사에서는 더 이상 고려하지 않을 것이다.)

다시 한 번 Nullable<T>예를 들어 보자. 생성자를 사용하여 int로 바꿀 수 있습니다 Nullable<int>. C # 컴파일러는 널 입력 가능 “리프팅”을 처리하지만, 그렇지 않은 경우 리프팅 변환이 간단합니다.

int M(int x) { whatever }

로 변환

Nullable<int> M(Nullable<int> x) 
{ 
    if (x == null) 
        return null; 
    else 
        return new Nullable<int>(whatever);
}

그리고 재산 Nullable<int>으로 다시 돌아가는 int것은 Value재산으로 이루어집니다 .

핵심 비트 인 함수 변환입니다. Nullable 연산의 실제 의미 ( null확산 에 대한 연산) null가 변환에서 어떻게 캡처 되는지 확인합니다 . 우리는 이것을 일반화 할 수 있습니다.

당신이에서 함수가 있다고 가정 int에 int우리의 원래처럼 M. nullable 생성자를 통해 결과를 실행할 수 있기 때문에 intand를 반환 하는 함수로 쉽게 만들 수 있습니다 Nullable<int>. 이제 다음과 같은 고차 방법이 있다고 가정하십시오.

static Nullable<T> Bind<T>(Nullable<T> amplified, Func<T, Nullable<T>> func)
{
    if (amplified == null) 
        return null;
    else
        return func(amplified.Value);
}

당신이 그걸로 무엇을 할 수 있습니까? an int을 반환하거나 int, inta Nullable<int>를 반환하고 a 를 반환하는 모든 메서드 는 이제 nullable 의미를 적용 할 수 있습니다.

또한 : 두 가지 방법이 있다고 가정하십시오.

Nullable<int> X(int q) { ... }
Nullable<int> Y(int r) { ... }

그리고 당신은 그것들을 작성하고 싶습니다 :

Nullable<int> Z(int s) { return X(Y(s)); }

즉, Z의 조성물 X및 Y. 때문에하지만 당신은 할 수 없어 X을 소요 int하고, Y리턴한다 Nullable<int>. 그러나 “바인드”작업이 있으므로 다음 작업을 수행 할 수 있습니다.

Nullable<int> Z(int s) { return Bind(Y(s), X); }

모나드에 대한 바인드 작업은 증폭 된 유형의 함수 구성을 작동시키는 것입니다. 위에서 언급 한 “규칙”은 모나드가 정상적인 기능 구성 규칙을 유지한다는 것입니다. 아이덴티티 함수로 구성하면 원래의 함수가되고 그 컴포지션은 연관됩니다.

C #에서 “Bind”는 “SelectMany”라고합니다. 시퀀스 모나드에서 어떻게 작동하는지 살펴보십시오. 값을 시퀀스로 바꾸고 시퀀스에 대한 연산을 바인딩하는 두 가지가 필요합니다. 보너스로, 우리는 또한 “시퀀스를 가치로 되돌려 놓았습니다”. 이러한 작업은 다음과 같습니다.

static IEnumerable<T> MakeSequence<T>(T item)
{
    yield return item;
}
// Extract a value
static T First<T>(IEnumerable<T> sequence)
{
    // let's just take the first one
    foreach(T item in sequence) return item; 
    throw new Exception("No first item");
}
// "Bind" is called "SelectMany"
static IEnumerable<T> SelectMany<T>(IEnumerable<T> seq, Func<T, IEnumerable<T>> func)
{
    foreach(T item in seq)
        foreach(T result in func(item))
            yield return result;            
}

nullable 모나드 규칙은 “nullable을 생성하는 두 함수를 결합하여 내부 함수가 null인지 확인하고, 그렇지 않으면 null을 생성하고 그렇지 않은 경우 결과와 함께 외부 함수를 호출합니다.” 이것이 원하는 nullable의 의미입니다.

시퀀스 모나드 규칙은 “서열을 생성하는 두 함수를 결합하고, 내부 함수에 의해 생성 된 모든 요소에 외부 함수를 적용한 다음 모든 결과 시퀀스를 함께 연결하는 것”입니다. 모나드의 기본 의미론은 Bind/ SelectMany메소드 에서 캡처됩니다 . 이것은 모나드가 실제로 무엇을 의미 하는지 알려주는 방법입니다 .

우리는 더 잘할 수 있습니다. int 시퀀스와 int를 가져 와서 문자열 시퀀스를 생성하는 메소드가 있다고 가정하십시오. 하나의 입력이 다른 입력의 출력과 일치하는 한 다른 증폭 유형을 가져오고 반환하는 함수의 구성을 허용하도록 바인딩 작업을 일반화 할 수 있습니다.

static IEnumerable<U> SelectMany<T,U>(IEnumerable<T> seq, Func<T, IEnumerable<U>> func)
{
    foreach(T item in seq)
        foreach(U result in func(item))
            yield return result;            
}

이제이 개별 정수를 정수 시퀀스로 증폭합니다.이 특정 정수를 문자열 시퀀스로 증폭하고 문자열 시퀀스로 증폭합니다. 이제 두 연산을 모두 합치십시오. “문자열의 모든 순서.” Monads를 사용하면 증폭 을 구성 할 수 있습니다 .

어떤 문제를 해결하고 가장 많이 사용되는 장소는 무엇입니까?

그것은 “싱글 톤 패턴이 어떤 문제를 해결합니까?”

모나드는 일반적으로 다음과 같은 문제를 해결하는 데 사용됩니다.

• 이 유형에 대해 새로운 기능을 만들어야하지만이 유형에 대해 이전 기능을 결합하여 새로운 기능을 사용해야합니다.
• 유형에 대한 많은 작업을 캡처하고 해당 작업을 컴포저 블 객체로 나타내어 적절한 일련의 작업을 나타낼 때까지 더 크고 더 큰 컴포지션을 구축 한 다음 결과에서 결과를 얻어야합니다.
• 부작용을 싫어하는 언어로 부작용 작업을 깨끗하게 표현해야합니다.

C #은 디자인에서 모나드를 사용합니다. 이미 언급했듯이, nullable 패턴은 “아마도 모나드”와 매우 유사합니다. LINQ는 전적으로 모나드로 만들어졌습니다. 이 SelectMany방법은 작업 구성의 의미 론적 작업입니다. (Erik Meijer는 모든 LINQ 기능이 실제로 구현 될 수 있다는 점을 좋아 SelectMany합니다. 다른 모든 기능은 편의에 불과합니다.)

내가 찾고있는 이해를 명확히하기 위해 모나드가있는 FP 응용 프로그램을 OOP 응용 프로그램으로 변환한다고 가정 해 봅시다. 모나드의 책임을 OOP 앱에 이식하려면 어떻게해야합니까?

대부분의 OOP 언어에는 모나드 패턴 자체를 직접 표현할 수있는 충분한 유형의 시스템이 없습니다. 일반 유형보다 유형이 높은 유형을 지원하는 유형 시스템이 필요합니다. 그래서 나는 그것을 시도하지 않을 것입니다. 오히려 각 모나드를 나타내는 제네릭 형식을 구현하고 필요한 세 가지 작업을 나타내는 메서드를 구현합니다. 값을 증폭 된 값으로 변환, (아마도) 증폭 된 값을 값으로 변환 및 함수를 증폭되지 않은 값으로 변환 증폭 된 값에 대한 함수.

시작하기 좋은 곳은 C #에서 LINQ를 구현 한 방법입니다. SelectMany방법을 연구하십시오 . 시퀀스 모나드가 C #에서 어떻게 작동하는지 이해하는 것이 중요합니다. 매우 간단한 방법이지만 매우 강력합니다!

제안, 추가 읽기 :

1. C #에서 모나드에 대한보다 심층적이고 이론적 인 설명 을 위해 주제에 대한 저의 ( Eric Lippert ) 동료 Wes Dyer의 기사를 강력히 추천 합니다. 이 기사는 모나드가 마지막으로 “클릭”했을 때 설명했습니다.
   • Monads의 놀라운 일
2. 왜 모나드를 원할 수 있는지에 대한 좋은 예입니다 (예제에서 Haskell 사용) .
   • 모나드를 발명했을 수도 있습니다! (그리고 아마도 당신은 이미 가지고 있습니다.) Dan Piponi
3. 이전 기사의 “번역”을 JavaScript로 분류합니다.
   • James Coglan 이 읽은 모나드에 대한 최고의 소개 중 일부를 Haskell에서 JavaScript로 번역

답변

# the return function
def unit[A] (x: A): M[A]

# called "bind" in Haskell
def flatMap[A,B] (m: M[A]) (f: A => M[B]): M[B]

# Other two can be written in term of the first two:

def map[A,B] (m: M[A]) (f: A => B): M[B] =
  flatMap(m){ x => unit(f(x)) }

def andThen[A,B] (ma: M[A]) (mb: M[B]): M[B] =
  flatMap(ma){ x => mb }

    데프 유닛 [A] (x : A) : 옵션 [A] = 약간 (x)

    def flatMap [A, B] (m : 옵션 [A]) (f : A => 옵션 [B]) : 옵션 [B] =
      m 일치 {
       case None => 없음
       case Some (x) => f (x)
      }

    데프 유닛 [A] (x : A) :리스트 [A] =리스트 (x)

    def flatMap [A, B] (m : 목록 [A]) (f : A => 목록 [B]) : 목록 [B] =
      m 일치 {
        경우 Nil => Nil
        사례 x :: xs => f (x) ::: flatMap (xs) (f)
      }

for {
  i <- 1 to 4
  j <- 1 to i
  k <- 1 to j
} yield i*j*k

(1 to 4).flatMap { i =>
  (1 to i).flatMap { j =>
    (1 to j).map { k =>
      i*j*k }}}

lookupVenue: String => Option[Venue]
getLoggedInUser: SessionID => Option[User]
reserveTable: (Venue, User) => Option[ConfNo]

val user = getLoggedInUser(session)
val confirm =
  if(!user.isDefined) None
  else lookupVenue(name) match {
    case None => None
    case Some(venue) =>
      val confno = reserveTable(venue, user.get)
      if(confno.isDefined)
        mailTo(confno.get, user.get)
      confno
  }

val confirm = for {
  venue <- lookupVenue(name)
  user <- getLoggedInUser(session)
  confno <- reserveTable(venue, user)
} yield {
  mailTo(confno, user)
  confno
}

f: x -> 1 / x
g: y -> 2 * y

e = {
  type: error,
  message: 'I got error trying to divide 1 by 0'
}

e = {
  type: error,
  message: 'Our committee to decide what is 1/0 is currently away'
}

1/0                // => Infinity
parseInt(Infinity) // => NaN
NaN < 0            // => false
false + 1          // => 1