Programming

def isEMail(s: String): Boolean    // 전자우편 주소인지 아닌지
def getDomain(s: String): String    // 전자 주소의 도메인 리턴
def getUser(s: String): String          // 전자 주소의 사용자 리턴

if (isEMail(s)) println(getUser(s) +" AT "+ getDomain(s))
else println("not an email address")

=>  전자 우편 문자열을 Email(user, domain) 으로 패턴 매치할 수 있다면?

s match {
  case EMail(user, domain) => println(user +" AT "+ domain)
  case _ => println("not an email address")
}

// 같은 사용자의 전자우편 주소 2개가 연속으로 있는 경우

ss match {
  case EMail(u1, d1) :: EMail(u2, d2) :: _ if (u1 == u2) => ...
...
}

object EMail {

  def apply(user: String, domain: String) = user +"@"+ domain   // 인젝션 메소드 (선택적)
       // EMail("John", "epfl.ch") => "John@epfl.ch" 반환 : 두 문자열을 취해서 전자우편 주소 문자열을 만든다.

      // apply 메소드를 명시적으로 만들고 싶다면 Function2[String, String, String] 함수 타입 상속

      // object EMail extends ((String, String) => String) { ... }

  def unapply(str: String): Option[(String, String)] = {     // 익스트랙터 메소드(필수)
    val parts = str split "@"
    if (parts.length == 2) Some(parts(0), parts(1)) else None
  }

     // 전자우편 주소 문자열을 받아서 (사용자 문자열, 도메인 문자열)을 Option 타입으로 반환 : apply와 역으로 진행

    // str이 전자 우편 주소라면 Some(user, domain), 아니라면 None 반환
}

=> 패턴 매치 시 익스트랙터 객체를 참조하는 패턴을 만나면 항상 그 익스트렉터의 unapply 메소드를 설렉터 식에 대해 호출

selectorString match { case EMail(user, domain) => ... }   // == EMail.unapply(selectorString)

     // unapply에서 None이 반환되면 패턴 매치가 이뤄지지 않는다.

    // Some(u,d)이 반환되면 패턴이 매치되어 unapply가 반환한 값이 각 변수에 바인딩 => user가 u에 domain이 d에 바인딩

val x: Any = ...
x match { case EMail(user, domain) => ... }

: 패턴 매처가 위 코드를 본다면 x가 EMail의 unapply 메소드 인자 타입인 String과 부합하는 지 살펴본다. 부합하는 경우, 매처는 값을 String으로 캐스팅해서 처리하고 부합하지 않으면 매치가 바로 실패한다.

" 같은 부분 문자열을 두 번 반복해 만든 문자열 매치 "

object Twice {
  def apply(s: String): String = s + s
  def unapply(s: String): Option[String] = {
    val length = s.length / 2
    val half = s.substring(0, length)
    if (half == s.substring(length)) Some(half) else None
  }
}

" 문자열의 모든 문자가 대문자인지 확인 "

object UpperCase {
  def unapply(s: String): Boolean = s.toUpperCase == s
}

" 전자우편 주소의 사용자 부분이 두 번 반복되는 대문자 문자열일 경우 매치 "

def userTwiceUpper(s: String) = s match {
  case EMail(Twice(x @ UpperCase()), domain) =>
    "match: "+ x +" in domain "+ domain
  case _ =>
    "no match"
}

scala> userTwiceUpper("DIDI@hotmail.com")
res0: java.lang.String = match: DI in domain hotmail.com

scala> userTwiceUpper("DIDO@hotmail.com")
res1: java.lang.String = no match

scala> userTwiceUpper("didi@hotmail.com")
res2: java.lang.String = no match

object Domain {

  def apply(parts: String*): String =
    parts.reverse.mkString(".")

  def unapplySeq(whole: String): Option[Seq[String]] =
    Some(whole.split("\\.").reverse)
}

" 이름이 tom이고 도메인이 .com인 전자우편 주소 검색 "

def isTomInDotCom(s: String): Boolean = s match {
  case EMail("tom", Domain("com", _*)) => true
  case _ => false
}

scala> isTomInDotCom("tom@sun.com")
res3: Boolean = true

scala> isTomInDotCom("peter@sun.com")
res4: Boolean = false

scala> isTomInDotCom("tom@acm.org")
res5: Boolean = false

" Builder 클래스 개요 "

package scala.collection.generic

class Builder[-Elem, +To] {
  def +=(elem: Elem): this.type
  def result(): To
  def clear()
  def mapResult(f: To => NewTo): Builder[Elem, NewTo] = ...
}

scala> import collection.immutable.BitSet
import collection.immutable.BitSet

scala> val bits = BitSet(1, 2, 3)
bits: scala.collection.immutable.BitSet = BitSet(1, 2, 3)

scala> bits map (_ * 2)
res13: scala.collection.immutable.BitSet = BitSet(2, 4, 6)

scala> bits map (_.toFloat)
res14: scala.collection.immutable.Set[Float]
= Set(1.0, 2.0, 3.0)

scala> Map("a" -> 1, "b" -> 2) map { case (x, y) => (y, x) }
res3: scala.collection.immutable.Map[Int,java.lang.String]
= Map(1 -> a, 2 -> b)

scala> Map("a" -> 1, "b" -> 2) map { case (x, y) => y }
res4: scala.collection.immutable.Iterable[Int]
= List(1, 2)

" TraversableLike의 map 구현 "

def map[B, That](p: Elem => B)
                (implicit bf: CanBuildFrom[Repr, B, That]): That = {   // ConBuildFrom 타입의 빌더 팩토리
  val b = bf(this)
  for (x <- this) b += f(x)
  b.result
}

" CanBuildFrom 트레이트 "

package scala.collection.generic

trait CanBuildFrom[-From, -Elem, +To] {
  def apply(from: From): Builder[Elem, To]       // 새로운 빌더를 만든다.
}

: From 타입의 컬렉션을 받아서 Elem 타입의 원소를 갖는 컬렉션 To를 반환하는 빌더 생성

=> CanBuildFrom의 암시적 정의를 제대로 하면 map의 타입 변환을 필요에 따라 변경할 수 있다.

" RNA 염기들 "

abstract class Base
case object A extends Base
case object T extends Base
case object G extends Base
case object U extends Base

object Base {
  val fromInt: Int => Base = Array(A, T, G, U)              // 정수를 Base 값으로 바꾸는 배열
  val toInt: Base => Int = Map(A -> 0, T -> 1, G -> 2, U -> 3)   // Base 값을 정수로 바꾸는 맵
}

import collection.IndexedSeqLike
import collection.mutable.{Builder, ArrayBuffer}
import collection.generic.CanBuildFrom

final class RNA1 private (val groups: Array[Int],       // 비트로 압축된 RNA 정보
                          val length: Int) extends IndexedSeq[Base] {       

                 // length : 배열 안의 염기 개수, IndexedSeq에는 length, apply 추상 메소드 존재

  import RNA1._

  def apply(idx: Int): Base = {             // 인덱스의 염기 반환
    if (idx < 0 || length <= idx)
      throw new IndexOutOfBoundsException
    Base.fromInt(groups(idx / N) >> (idx % N * S) & M)           
  }
}

object RNA1 {
  private val S = 2        // 염기를 표현하는 비트 수

  private val N = 32 / S         // Int(32 bit)에 들어갈 그룹의 수

  private val M = (1 << S) - 1       // 어떤 그룹만 떼어내기 위한 비트 마스크(11)

  def fromSeq(buf: Seq[Base]): RNA1 = {
    val groups = new Array[Int]((buf.length + N - 1) / N)   
    for (i <- 0 until buf.length)
      groups(i / N) |= Base.toInt(buf(i)) << (i % N * S)
    new RNA1(groups, buf.length)
  }

  def apply(bases: Base*) = fromSeq(bases)
}

scala> rna1.length
res2: Int = 5

scala> rna1.last
res3: Base = T

scala> rna1.take(3)
res4: IndexedSeq[Base] = Vector(A, U, G)

: IndexedSeq에 IndexedSeq를 반환하는 take 메소드가 있고 IndexedSeq 구현이 Vector => RNA1 X

=> RNA1 클래스의 take 메소드 오버라이드

def take(count: Int) : RNA1 = RNA1.fromSeq(super.take(count))

=> drop, filter과 같은 컬렉션 메소드도 똑같이 하기는 힘들다.

=> IndexedSeq의 구현 클래스인 IndexedSeqLike를 상속한다.

final class RNA2 private (
                           val groups: Array[Int],
                           val length: Int
                         ) extends IndexedSeq[Base] with IndexedSeqLike[Base, RNA2] {

  import RNA2._

  override def newBuilder: Builder[Base, RNA2] =
    new ArrayBuffer[Base] mapResult fromSeq

  def apply(idx: Int): Base = // RNA1과 같다.
}

scala> val rna2 = RNA2(A, U, G, G, T)
rna2: RNA2 = RNA2(A, U, G, G, T)

scala> rna2 map { case A => T case b => b }
res0: IndexedSeq[Base] = Vector(T, U, G, G, T)

scala> rna2 ++ rna2
res1: IndexedSeq[Base] = Vector(A, U, G, G, T, A, U, G, G, T)

: 모두 RNA2 타입이 아니라 IndexedSeq 타입이다.

" 패트리샤 트라이를 사용한 접두사 맵 구현 "

import collection._

class PrefixMap[T]

 extends mutable.Map[String, T]  with mutable.MapLike[String, T, PrefixMap[T]] {

        // MapLike 구현 클래스 상속을 통해 filter 같은 메소드에서 올바른 타입의 결과를 얻고 쉽게 컬렉션 메소드를 사용할 수 있다.

  var suffixes: immutable.Map[Char, PrefixMap[T]] = Map.empty    // 문자에 해당하는 PrefixMap 값을 보내는 맵
  var value: Option[T] = None      // 해당 노드와 관련된 Option 값

  def get(s: String): Option[T] =              // s키를 가진 노드의 value 리턴
    if (s.isEmpty) value
    else suffixes get (s(0)) flatMap (_.get(s substring 1))

  def withPrefix(s: String): PrefixMap[T] =      // 접두사 s로 시작하는 모든 하위 컬렉션 리턴
    if (s.isEmpty) this
    else {
      val leading = s(0)
      suffixes get leading match {
        case None =>
          suffixes = suffixes + (leading -> empty)
        case _ =>
      }
      suffixes(leading) withPrefix (s substring 1)
    }

  override def update(s: String, elem: T) =      // += 메소드
    withPrefix(s).value = Some(elem)

  override def remove(s: String): Option[T] =       // -= 메소드 
    if (s.isEmpty) { val prev = value; value = None; prev }
    else suffixes get (s(0)) flatMap (_.remove(s substring 1))

  def iterator: Iterator[(String, T)] =
    (for (v <- value.iterator) yield ("", v)) ++
    (for ((chr, m) <- suffixes.iterator; 
          (s, v) <- m.iterator) yield (chr +: s, v))
    
  def += (kv: (String, T)): this.type = { update(kv._1, kv._2); this }

  def -= (s: String): this.type  = { remove(s); this }

  override def empty = new PrefixMap[T]
}

" 접두사 맵의 동반 객체 "
import scala.collection.mutable.{Builder, MapBuilder}
import scala.collection.generic.CanBuildFrom

object PrefixMap extends {
  def empty[T] = new PrefixMap[T]     // 빈 PrefixMap 객체 반환

// 변경 불가능한 맵이나 집합은 비파괴적 원소 추가 메소드인 +를 사용하기 때문에 어떤 집합이나 맵을 만들려면 원하는 타입의 빈 집합이나 빈 맵을 만들어야 한다.

  def apply[T](kvs: (String, T)*): PrefixMap[T] = {    
    val m: PrefixMap[T] = empty
    for (kv <- kvs) m += kv
    m
  }

  def newBuilder[T]: Builder[(String, T), PrefixMap[T]] = 
    new MapBuilder[String, T, PrefixMap[T]](empty)

  implicit def canBuildFrom[T]
    : CanBuildFrom[PrefixMap[_], (String, T), PrefixMap[T]] = 
      new CanBuildFrom[PrefixMap[_], (String, T), PrefixMap[T]] {
        def apply(from: PrefixMap[_]) = newBuilder[T]
        def apply() = newBuilder[T]
      }
}