[scala] flatMap / Map 변환에 대한 이해를위한 것과 혼동

TL; DR은 최종 예제로 직접 이동

나는 노력하고 요약 할 것이다.

정의

for이해가 결합 구문 바로 가기입니다 flatMap및 map읽기에 대한 이유 쉽다 방법이다.

일을 조금 단순화하고 class앞서 언급 한 두 가지 방법을 모두 제공 하는 모든 것이 a라고 할 수 있다고 가정 하고 내부 유형이있는 a를 의미하는 monad기호 M[A]를 사용할 것 입니다.monadA

예

일반적으로 볼 수있는 몇 가지 모나드는 다음과 같습니다.

• List[String] 어디
  • M[X] = List[X]
  • A = String
• Option[Int] 어디
  • M[X] = Option[X]
  • A = Int
• Future[String => Boolean] 어디
  • M[X] = Future[X]
  • A = (String => Boolean)

map 및 flatMap

일반 모나드에서 정의 됨 M[A]

 /* applies a transformation of the monad "content" mantaining the
  * monad "external shape"
  * i.e. a List remains a List and an Option remains an Option
  * but the inner type changes
  */
  def map(f: A => B): M[B]

 /* applies a transformation of the monad "content" by composing
  * this monad with an operation resulting in another monad instance
  * of the same type
  */
  def flatMap(f: A => M[B]): M[B]

예 :

  val list = List("neo", "smith", "trinity")

  //converts each character of the string to its corresponding code
  val f: String => List[Int] = s => s.map(_.toInt).toList

  list map f
  >> List(List(110, 101, 111), List(115, 109, 105, 116, 104), List(116, 114, 105, 110, 105, 116, 121))

  list flatMap f
  >> List(110, 101, 111, 115, 109, 105, 116, 104, 116, 114, 105, 110, 105, 116, 121)

표현을 위해

1. <-기호를 사용하는 표현식의 각 행 flatMap은 마지막 호출 로 변환 되는 마지막 행을 제외하고 는 호출로 변환됩니다. map여기서 왼쪽의 “바운드 기호”는 매개 변수로 인수 함수에 전달됩니다 (what 이전에 f: A => M[B]) :

   // The following ...
   for {
     bound <- list
     out <- f(bound)
   } yield out
   
   // ... is translated by the Scala compiler as ...
   list.flatMap { bound =>
     f(bound).map { out =>
       out
     }
   }
   
   // ... which can be simplified as ...
   list.flatMap { bound =>
     f(bound)
   }
   
   // ... which is just another way of writing:
   list flatMap f
   

2. 하나만있는 for-expression 은 인수로 전달 된 표현식이 <-있는 map호출로 변환됩니다 .

   // The following ...
   for {
     bound <- list
   } yield f(bound)
   
   // ... is translated by the Scala compiler as ...
   list.map { bound =>
     f(bound)
   }
   
   // ... which is just another way of writing:
   list map f
   

이제 요점

당신이 볼 수 있듯이, map작업은 원래의 “모양”을 보존 monad같은이 위해 발생하므로, yield식 : A는 List남아 List의 조작에 의해 변환 된 내용으로 yield.

반면에의 각 바인딩 선 for은 연속 된의 구성 일 뿐이며 monads단일 “외부 모양”을 유지하려면 “평평하게 만들어야”합니다.

잠시 동안 각 내부 바인딩이 map호출 로 변환 되었지만 오른손이 동일한 A => M[B]기능이라고 가정 M[M[B]]하면 이해의 각 줄에 대해 a 로 끝납니다 .
전체 for구문 의 목적은 결론 변환을 수행 할 수A => M[B] 있는 최종 map연산을 추가하여 연속적인 모나드 연산 (즉, “모나드 형태”에서 값을 “리프트”하는 연산)의 연결을 쉽게 “평탄화” 하는 것입니다 .

이것이 기계적 방식으로 적용되는 번역 선택의 논리, 즉 n flatMap단일 map호출로 종료되는 중첩 호출을 설명하기를 바랍니다 .

인위적인 설명 예제
는 for구문 의 표현력을 보여주기위한 것입니다.

case class Customer(value: Int)
case class Consultant(portfolio: List[Customer])
case class Branch(consultants: List[Consultant])
case class Company(branches: List[Branch])

def getCompanyValue(company: Company): Int = {

  val valuesList = for {
    branch     <- company.branches
    consultant <- branch.consultants
    customer   <- consultant.portfolio
  } yield (customer.value)

  valuesList reduce (_ + _)
}

유형을 추측 할 수 있습니까 valuesList?

이미 말했듯이의 모양은 monad이해를 통해 유지되므로 Listin으로 시작 company.branches하고 List.
대신 내부 유형이 변경되고 다음 yield표현식에 의해 결정됩니다.customer.value: Int

valueList 이어야합니다 List[Int]