7.3

for 내장의 변환 규칙

• pat <- expr 과 같은 제너레이터 식에서 pat는 실제로 패턴 식 [ ex. (x,y) <- List((1,2), (3,4)) ]
• pat2 = expr과 같은 값 정의에서 pat2도 패턴으로 해석

// pat <- expr
pat <- expr.withFilter {case pat => true; case _ => false}

• 변환의 첫 단계로 pat <- expr을 바꿈
• 모든 내장식이 변환될 때 까지 여러 변환을 반복 적용할 수 있으며, 일부 단계는 그 후 새로운 for 내장을 만듬

// 1
// for (pat <- expr1) yield expr2
// expr1 map {case pat => expr2}
val proglang = List("Python", "C", "Scala", "Java", "Go")

for (lang <- proglang) yield lang.toUpperCase()
proglang map {case lang => lang.toUpperCase()}

res0: List[String] = List(PYTHON, C, SCALA, JAVA, GO)
res1: List[String] = List(PYTHON, C, SCALA, JAVA, GO)

• for 내장
• 1개의 제너레이터 + yield

// 2
// for (pat <- expr1) expr2
// expr1 foreach { case pat => expr2 }
for (lang <- proglang) println(lang)
proglang foreach { case lang => println(lang) }

Python
C
Scala
Java
Go
res2: Unit = ()
Python
C
Scala
Java
Go
res3: Unit = ()

• for 루프
• 1개의 제너레이터 + 부수효과(Side Effect)

// 3
// for (pat1 <- expr1; pat2 <- expr2; ...) yield exprN
// expr1 flatMap { case pat1 => for (pat2 <- expr2 ...) yield exprN }
for (lang <- proglang; chrr <- lang) yield chrr.toUpper
proglang flatMap {case lang => for (chrr <- lang) yield chrr.toUpper}

res4: List[Char] = List(P, Y, T, H, O, N, C, S, C, A, L, A, J, A, V, A, G, O)
res5: List[Char] = List(P, Y, T, H, O, N, C, S, C, A, L, A, J, A, V, A, G, O)

• for 내장
• 두 개 이상의 제너레이터 + yield

// 4
// for (pat1 <- expr1 ; pat2 <- epxr2; ...) exprN
// expr1 foreach { case pat1 => for (pat2 <- expr2 ...) yield exprN }
for (lang <- proglang; chrr <- lang) println(chrr)
proglang foreach { case lang => for (chrr <- lang) yield println(chrr) }

P
y
t
h
o
n
C
S
c
a
l
a
J
a
v
a
G
o
res6: Unit = ()
P
y
t
h
o
n
C
S
c
a
l
a
J
a
v
a
G
o
res7: Unit = ()

• for 루프
• 두 개 이상의 제너레이터

// 5
// pat1 <- expr1 if guard
// pat1 <- expr1 withFilter ((arg1, arg2, ...) => guard)
val newProglang = for { lang <- proglang if lang.length > 3 } yield lang
val newProglang2 = for { lang <- proglang withFilter(lang => lang.length > 3) } yield lang

newProglang: List[String] = List(Python, Scala, Java)
newProglang2: List[String] = List(Python, Scala, Java)

• 한 개의 제너레이터 + 가드 + yield

// 6
// pat1 <- expr1; pat2 = expr2
// (pat1, pat2) <- for {
//  x1 @ pat1 <- expr1
// } yield {
//  val x2 @ apt2 = expr2
//  (x1, x2)
// }
val suffixProglang = for { lang <- proglang ; suffix = "_lang" } yield lang+suffix
val suffixProglang2 = for {
                          (lang, suffix) <- for {      // 최종적으로 두 패턴 쌍 반환
                            x1 @ lang <- proglang      // x1 @ lang == x1에 lang이 일치하는 전체 식에 대한 값 대입
                          } yield {
                            val x2 @ suffix = "_lang"  // x2 에 suffix 값 대입
                            (x1, x2)                   // 튜플 반환 (x1, x2) == (lang, suffix)
                          }
                      } yield lang+suffix

suffixProglang: List[String] = List(Python_lang, C_lang, Scala_lang, Java_lang, Go_lang)
suffixProglang2: List[String] = List(Python_lang, C_lang, Scala_lang, Java_lang, Go_lang)

• 1 개의 제네레이터 + 변수 선언

val map = Map("One" -> 1, "Two" -> 2)

val list1 = for {
  (key, value) <- map
  i10 = value + 10
} yield (i10)

val list2 = for {
  (i, i10) <- for {
    x1 @ (key, value) <- map
  } yield {
    val x2 @ i10 = value + 10
    (x1, x2)
  }
} yield(i10)

map: scala.collection.immutable.Map[String,Int] = Map(One -> 1, Two -> 2)
list1: scala.collection.immutable.Iterable[Int] = List(11, 12)
list2: scala.collection.immutable.Iterable[Int] = List(11, 12)

• 맵을 순회하는 제너레이터 map에 대해 키-값 쌍으로 패턴매칭 및 변환 수행

val ignoreRegex = """^\s*(#.*|\s*)$""".r
val kvRegex = """^\s*([^=]+)\s*=\s*([^#]+)\s*.*$""".r

val properties ="""
    |book.name = Programming Scala, Second Edition
    |book.authors = Dean Wampler and Alex Payne
    |book.puhlisher = O'Reilly
    |book.publication-year = 2014
  """.stripMargin

val kvPairs = for {
  prop <- properties.split("\n")
  if ignoreRegex.findFirstIn(prop) == None
  kvRegex(key, value) = prop
} yield (key.trim, value.trim)

kvPairs: Array[(String, String)] = Array((book.name,Programming Scala, Second Edition), (book.authors,Dean Wampler and Alex Payne), (book.puhlisher,O'Reilly), (book.publication-year,2014))