Programming

trait Abstract {
  type T
  def transform(x: T): T
  val initial: T
  var current: T
}

class Concrete extends Abstract {
  type T = String
  def transform(x: String) = x + x
  val initial = "hi"
  var current = initial
}

val initial: String

def initial: String

=> 클라이언트 코드는 obj.initial로 val와 메소드를 같은 방식으로 사용 가능

but, val이라면 같은 값을 얻을 수 있다는 확신이 있지만 메소드라면 그런 보장이 없다.

=> 추상 val은 구현시 val 정의를 사용해야한다는 제약

=> 추상 메소드 선언은 val이나 메소드 정의로 사용 가능하다.

abstract class Fruit {
  val v: String // `v' for value
  def m: String // `m' for method
}

abstract class Apple extends Fruit {
  val v: String
  val m: String // OK to override a `def' with a `val'
}

abstract class BadApple extends Fruit {
  def v: String // ERROR: cannot override a `val' with a `def'
  def m: String
}

trait RationalTrait { 
  val numerArg: Int       // 분자
  val denomArg: Int      // 분모
} 

new RationalTrait {     // 트레이트를 혼합한 익명 클래스 인스턴스 => new Rational(1, 2)와 상응하는 효과
  val numerArg = 1
  val denomArg = 2
}

 new Rational(expr1, expr2)

new RationalTrait {
  val numerArg = expr1
  val denomArg = expr2
}

trait RationalTrait { 
  val numerArg: Int 
  val denomArg: Int 
  require(denomArg != 0)
  private val g = gcd(numerArg, denomArg)
  val numer = numerArg / g
  val denom = denomArg / g
  private def gcd(a: Int, b: Int): Int = 
    if (b == 0) a else gcd(b, a % b)
  override def toString = numer +"/"+ denom
}

scala> val x = 2
x: Int = 2

scala> new RationalTrait {
     |   val numerArg = 1 * x
     |   val denomArg = 2 * x
     | }
java.lang.IllegalArgumentException: requirement failed     
   at scala.Predef$.require(Predef.scala:134)
   at RationalTrait$class.$init$(:8)
      at $anon$1.(:8)
      ...

" 익명 클래스 표현식에서 필드를 미리 초기화 "

scala> new { 
     |   val numerArg = 1 * x
     |   val denomArg = 2 * x 
     | } with RationalTrait
res1: java.lang.Object with RationalTrait = 1/2

" 객체 정의에서 필드를 미리 초기화 "

object twoThirds extends {
  val numerArg = 2
  val denomArg = 3
} with RationalTrait

" 클래스 정의에서 필드를 미리 초기화 "

class RationalClass(n: Int, d: Int) extends {
  val numerArg = n
  val denomArg = d
} with RationalTrait {
  def + (that: RationalClass) = new RationalClass(
    numer * that.denom + that.numer * denom,
    denom * that.denom
  )
}

scala> object Demo {
     |   val x = { println("initializing x"); "done" }
     | }
defined module Demo

scala> Demo
initializing x
res3: Demo.type = Demo$@17469af

scala> Demo.x
res4: java.lang.String = done

------------------------------------------------

scala> object Demo {
     |   lazy val x = { println("initializing x"); "done" }
     | }
defined module Demo

scala> Demo
res5: Demo.type = Demo$@11dda2d

scala> Demo.x
initializing x
res6: java.lang.String = done

" 트레이트를 지연 val로 초기화하기 "

trait LazyRationalTrait { 
  val numerArg: Int 
  val denomArg: Int 
  lazy val numer = numerArg / g
  lazy val denom = denomArg / g
  override def toString = numer +"/"+ denom
  private lazy val g = {
    require(denomArg != 0)
    gcd(numerArg, denomArg)
  }
  private def gcd(a: Int, b: Int): Int = 
    if (b == 0) a else gcd(b, a % b)
}

scala> val x = 2
x: Int = 2

scala> new LazyRationalTrait {
     |   val numerArg = 1 * x
     |   val denomArg = 2 * x
     | }
res7: java.lang.Object with LazyRationalTrait = 1/2

class Food
abstract class Animal {
  def eat(food: Food)
}

class Grass extends Food
class Cow extends Animal {
  override def eat(food: Grass) {} // Animal의 eat 메소드와 Cow의 eat 메소드 파라미터 타입이 다르기 때문에 컴파일 오류
}

class Food
abstract class Animal {
  def eat(food: Food)
}
class Grass extends Food
class Cow extends Animal {
  override def eat(food: Grass) {} // This won't compile,
}                                  // but if it did,...

class Fish extends Food
val bessy: Animal = new Cow
bessy eat (new Fish)     // ...you could feed fish to cows.

class Food
abstract class Animal {
  type SuitableFood <: Food   
  def eat(food: SuitableFood)
}

class Grass extends Food
class Cow extends Animal {
  type SuitableFood = Grass
  override def eat(food: Grass) {}
}

scala> class Fish extends Food
defined class Fish

scala> val bessy: Animal = new Cow
bessy: Animal = Cow@2e3919

scala> bessy eat (new Fish)
:12: error: type mismatch;
   found   : Fish
   required: bessy.SuitableFood   // 객체와 멤버를 타입에 포함시킬 수 있다. 
         bessy eat (new Fish)
                    ^

class Outer {
  class Inner
}
=> 내부 클래스를 자바는 Outer.Inner로 표현하고 스칼라는 Outer#Inner로 표현('.' 문법은 객체에만 사용된다.)

val o1 = new Outer 
val o2 = new Outer

=> o1.Inner와 o2.Inner은 경로 의존 타입이고 더 일반적인 타입 Outer#Inner의 서브 타입이다.

Outer#Inner은 Outer 타입의 임의의 외부 객체 내부에 있는 Inner 클래스를 의미

o1.Inner와 o2.Inner은 특정 외부 객체의 Inner 클래스를 의미

=> 내부 클래스 인스턴스는 그 인스턴스를 둘러싼 외부 클래스의 인스턴스를 가리키는 참조 존재

=> 내부 클래스 인스턴스에서 외부 클래스의 인스턴스를 지정해야 한다.

scala> new o1.Inner
res11: o1.Inner = Outer$Inner@1df6ed6

scala> new Outer#Inner
:7: error: Outer is not a legal prefix for
    a constructor
         new Outer#Inner
                   ^

object Color extends Enumeration {
  val Red = Value
  val Green = Value
  val Blue = Value
}

object Color extends Enumeration {
  val Red, Green, Blue = Value
}

object Direction extends Enumeration {
  val North = Value("North")
  val East = Value("East")
  val South = Value("South")
  val West = Value("West")
}

scala> for (d <- Direction.values) print(d +" ")
North East South West 

scala> Direction.East.id
res14: Int = 1

scala> Direction(1)
res15: Direction.Value = East

abstract class Currency {
  val amount: Long                        // 추상 필드
  def designation: String                 //  USD, Yen, Euro
  override def toString = amount +" "+ designation
  def + (that: Currency): Currency = ...
  def * (x: Double): Currency = ...
}

abstract class Dollar extends Currency {
  def designation = "USD"
}
abstract class Euro extends Currency {
  def designation = "Euro"
}

=>  Dollar 객체의 + 메소드에서 Euro 객체가 파라미터로 들어올 수 있다.

=>  추상 타입 사용

abstract class AbstractCurrency {
  type Currency <: AbstractCurrency
  val amount: Long
  def designation: String 
  override def toString = amount +" "+ designation
  def + (that: Currency): Currency = new Currency {  // 컴파일 오류 발생 

             // 스칼라는 추상 타입의 인스턴스를 만들 수 없고, 추상 타입을 다른 클래스의 슈퍼 타입으로 만들 수 없다.
    val amount = this.amount + that.amount
  }
  def * (x: Double): Currency = ...
}

abstract class Dollar extends AbstractCurrency {
  type Currency = Dollar
  def designation = "USD"
}

abstract class AbstractCurrency {
  type Currency <: AbstractCurrency // abstract type
  def make(amount: Long): Currency  // factory method
  ...                               // rest of class
}

=> Currency가 Currency를 만들 수 있다.

=> Currency를 만들 방법이 make 밖에 없는데 Currency 안에 make 존재 => 최초의 Currency 객체를 만들어낼 방법이 없다. => 다른 생성자를 추가할 수 있지만 본질적으로 make와 하는 일이 같다. 

=> 추상 타입과 팩토리 메소드를 밖으로 옮긴다.

abstract class CurrencyZone {
  type Currency <: AbstractCurrency
  def make(x: Long): Currency
  
  abstract class AbstractCurrency {
    val amount: Long
    def designation: String 
    override def toString = amount +" "+ designation
    def + (that: Currency): Currency = 
      make(this.amount + that.amount)
    def * (x: Double): Currency = 
      make((this.amount * x).toLong)
  }
}

object US extends CurrencyZone {
  abstract class Dollar extends AbstractCurrency {
    def designation = "USD"
  }
  type Currency = Dollar
  def make(x: Long) = new Dollar { val amount = x }
}

" 통화의 하위 단위 표현, 미국 달러의 하위 단위는 센트, amount 필드가 금액을 달러 대신 센트 단위로 저장 "

 
object US extends CurrencyZone {
  abstract class Dollar extends AbstractCurrency {
    def designation = "USD"
  }
  type Currency = Dollar
  def make(cents: Long) = new Dollar {
    val amount = cents
  }
  val Cent = make(1)         // 1센트 동전
  val Dollar = make(100)    // 1달러 지폐
  val CurrencyUnit = Dollar   // 표준 화폐 단위

}

----------------------------------------------

  override def toString =      // 10달러와 23센트의 합은 10.23 USD
  ((amount.toDouble / CurrencyUnit.amount.toDouble)
   formatted ("%."+ decimals(CurrencyUnit.amount) +"f")     // 자바의 String.format과 비슷
   +" "+ designation)

private def decimals(n: Long): Int = 
  if (n == 1) 0 else 1 + decimals(n / 10)

------------------------------------------------

object Europe extends CurrencyZone {
  abstract class Euro extends AbstractCurrency {
    def designation = "EUR"
  }
  type Currency = Euro
  def make(cents: Long) = new Euro {
    val amount = cents
  }
  val Cent = make(1)
  val Euro = make(100)
  val CurrencyUnit = Euro
}

object Japan extends CurrencyZone {
  abstract class Yen extends AbstractCurrency {
    def designation = "JPY"
  }
  type Currency = Yen
  def make(yen: Long) = new Yen {
    val amount = yen
  }
  val Yen = make(1)
  val CurrencyUnit = Yen
}

" 환율 계산 "

object Converter {
  var exchangeRate = Map(
    "USD" -> Map("USD" -> 1.0   , "EUR" -> 0.7596, 
                 "JPY" -> 1.211 , "CHF" -> 1.223),
    "EUR" -> Map("USD" -> 1.316 , "EUR" -> 1.0   , 
                 "JPY" -> 1.594 , "CHF" -> 1.623),
    "JPY" -> Map("USD" -> 0.8257, "EUR" -> 0.6272, 
                 "JPY" -> 1.0   , "CHF" -> 1.018),
    "CHF" -> Map("USD" -> 0.8108, "EUR" -> 0.6160, 
                 "JPY" -> 0.982 , "CHF" -> 1.0  )
  )
}

def from(other: CurrencyZone#AbstractCurrency): Currency = 
  make(math.round(
    other.amount.toDouble * Converter.exchangeRate
      (other.designation)(this.designation)))

=> head와 tail은 리스트 표현 타입을 통해 상수 시간 구현 가능

class SlowAppendQueue[T](elems: List[T]) {   
  def head = elems.head
  def tail = new SlowAppendQueue(elems.tail)
  def enqueue(x: T) = new SlowAppendQueue(elems ::: List(x))   // 비효율적, 원소의 개수에 비례하는 시간
}

" enqueue 연산을 상수 시간에 하기 위해 리스트의 원소를 뒤집은 버전 " => head와 tail 비효율적

class SlowHeadQueue[T](smele: List[T]) { // Not efficient
  // smele is elems reversed
  def head = smele.last
  def tail = new SlowHeadQueue(smele.init)
  def enqueue(x: T) = new SlowHeadQueue(x :: smele)
}

object Queue {
  def apply[T](xs: T*) = new Queue[T](xs.toList, Nil)   

      // Queue(1,2,3) => Queue.apply(1,2,3) : 메소드가 객체에 속해 있지만 전역 메소드를 호출한 것과 같은 효과
}

scala> def doesCompile(q: Queue[AnyRef]) {}   

            // Queue 트레이트는 Queue[Int], Queue[AnyRef] 처럼 파라미터화된 타입을 지정하도록 허용한다.
doesCompile: (Queue[AnyRef])Unit

trait Queue[+T] { ... }   

// 스칼라에게 Queue[String]을 Queue[AnyRef]의 서브타입으로 간주하라고 요구한다. 컴파일러는 Queue의 구현에서 해당 서브타입이 건전한지 검사한다.

trait Queue[-T] { ... }   

// T가 S의 서브타입인 경우 Queue[S]가 Queue[T]의 서브타입

class Cell[+T](init: T) {
  private[this] var current = init
  def get = current
  def set(x: T) { current = x }
}

Cell.scala:7: error: covariant type T occurs in
contravariant position in type T of value x
   def set(x: T) = current = x
              ^

val c1 = new Cell[String]("abc")
val c2: Cell[Any] = c1
c2.set(1)           // String을 받는 c1 인스턴스에 Int 타입을 넣는다. => 오류, 함수형 객체는 이런 경우 발생 X
val s: String = c1.get 

String[] a1 = { "abc" };
Object[] a2 = a1;
a2[0] = new Integer(17);  // 컴파일은 잘 되지만 실행할 때 ArrayStore 예외 발생  
String s = a1[0];

// 컴파일 시 항상 합법적, 자바 언어와 마찬가지로 공변적으로 다룬다.

scala> val a2: Array[Object] =
         a1.asInstanceOf[Array[Object]]
a2: Array[java.lang.Object] = Array(abc)

" Queue가 공변적이라고 가정 "

class StrangeIntQueue extends Queue[Int] {
  override def enqueue(x: Int) = {
    println(math.sqrt(x))
    super.enqueue(x)
  }
}

val x: Queue[Any] = new StrangeIntQueue
x.enqueue("abc")                // 올바르지 않음

=> 실제 공변성을 가진 Queue를 컴파일하면 (

class Queue[+T] {
  def enqueue(x: T) = 
   ...
}

Queues.scala:11: error: covariant type T occurs in
contravariant position in type T of value x
  def enqueue(x: T) = 
             ^

class Queue[+T] (private val leading: List[T],
    private val trailing: List[T] ) {
  def enqueue[U >: T](x: U) = 
    new Queue[U](leading, x :: trailing) // ...
}

class Fruit
class Apple extends Fruit
class Orange extends Fruit

class StrangeQueue extends Queue[Apple](Nil, Nil ) {
  override def enqueue[Fruit>:Apple](x: Fruit) = {
    super.enqueue(x)
  }
}

val x: Queue[Fruit] = new StrangeQueue 

x.enqueue(new Orange)

" 반공변 출력 채널 "

trait OutputChannel[-T] {
  def write(x: T)
}

" 한 타입 안에 공변성과 반공변성이 섞여 있는 함수 트레이트 "

trait Function1[-S, +T] {
  def apply(x: S): T
}

" Ordered 트레이트를 혼합한 Person 클래스 "

class Person(val firstName: String, val lastName: String)
    extends Ordered[Person] {

  def compare(that: Person) = {
    val lastNameComparison =
      lastName.compareToIgnoreCase(that.lastName)
    if (lastNameComparison != 0)
      lastNameComparison
    else
      firstName.compareToIgnoreCase(that.firstName)
  }

  override def toString = firstName +" "+ lastName
}

" 상위 바운드를 사용한 병합 정렬 - Ordered 트레이트를 믹스인한 모든 타입에 대해 정렬 수행 가능 "

 * Int는 Ordered[Int]의 서브타입이 아니기 때문에 제한 

def orderedMergeSort[T <: Ordered[T]](xs: List[T]): List[T] = {
  def merge(xs: List[T], ys: List[T]): List[T] =
    (xs, ys) match {
      case (Nil, _) => ys
      case (_, Nil) => xs
      case (x :: xs1, y :: ys1) =>
        if (x < y) x :: merge(xs1, ys)
        else y :: merge(xs, ys1)
    }
  val n = xs.length / 2
  if (n == 0) xs
  else {
    val (ys, zs) = xs splitAt n
    merge(orderedMergeSort(ys), orderedMergeSort(zs))
  }
}