TL; DR перейти непосредственно к последнему примеру
Я попробую и резюмирую.
Определения
forПонимание является синтаксис ярлыка , чтобы объединить flatMapи mapтаким образом , который легко читать и рассуждать о.
Давайте немного упростим ситуацию и предположим, что каждый, classкоторый предоставляет оба вышеупомянутых метода, может называться a, monadи мы будем использовать этот символ M[A]для обозначения a monadс внутренним типом A.
Примеры
Некоторые часто встречающиеся монады включают:
List[String] где
M[X] = List[X] A = String
Option[Int] где
Future[String => Boolean] где
M[X] = Future[X]A = (String => Boolean)
карта и flatMap
Определен в общей монаде M[A]
def map(f: A => B): M[B]
def flatMap(f: A => M[B]): M[B]
например
val list = List("neo", "smith", "trinity")
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)
для выражения
Каждая строка в выражении, использующем <-символ, преобразуется в flatMapвызов, за исключением последней строки, которая преобразуется в завершающий mapвызов, где «связанный символ» с левой стороны передается в качестве параметра функции аргумента (что мы ранее называли f: A => M[B]):
for {
bound <- list
out <- f(bound)
} yield out
list.flatMap { bound =>
f(bound).map { out =>
out
}
}
list.flatMap { bound =>
f(bound)
}
list flatMap f
For-выражение только с одним <-преобразуется в mapвызов с выражением, переданным в качестве аргумента:
for {
bound <- list
} yield f(bound)
list.map { bound =>
f(bound)
}
list map f
Теперь к делу
Как видите, mapоперация сохраняет «форму» оригинала monad, то же самое происходит и с yieldвыражением: a Listостается Listс содержимым, преобразованным операцией в yield.
С другой стороны, каждая линия привязки в шаблоне for- это просто последовательность monads, которую необходимо «сплющить», чтобы сохранить единую «внешнюю форму».
Предположим на мгновение, что каждая внутренняя привязка была преобразована в mapвызов, но правая часть была той же самой A => M[B]функцией, в результате вы получите a M[M[B]]для каждой строки в понимании.
Цель всего 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]