S01E05

14장. 단언문과 단위 테스트

14.1 단언문

• assert 메소드를 호출하는 방식으로 단언문을 작성하며 조건을 만족하지 않는 경우 AssertionError를 던진다.
• assert(c, e) 두 개 인자로 사용되는 경우 : 조건 c를 만족하지 않을 경우 설명 e를 포함하는 AssertionError를 던진다. : e는 Any 타입으로 AssertionError객체에 e.toString을 호출한다.
• ensuring 메소드는 술어 함수를 인자로 받고 true, false로 반환한다.

14.2 단위 테스트

• 자바도구 JUnit, TestNG
• 스칼라로 만들어준 ScalaTest, specs, ScalaCheck 등도 있다
  • org.scalatest.Suite 확장 클래스로 선언하여 test로 시작하는 메소드를 정의하고 execute()를 호출하면 스위트 안에 있는 테스트 메소드를 찾아서 실행
  • org.scalatest.FunSuite 확장 클래스로 선언하여 test 메소드를 정의하고 그 안에 코드 기입

14.3 실패 보고 시 더 많은 정보 제공하기

• === 연산자, expect 메소드를 사용하여 메시지 나타내기
• ScalaTest의 intercept 메소드 사용하여 예외 발생시키기

14.4 JUnit과 TestNG 사용

14.5 명세를 테스트로 사용하기

• 동작 주도 개발 테스트 스타일 ScalaTest에서 Spec, WordSpec, FlatSpec, FeatureSepc 등을 제공

14.6 프로퍼티 기반 테스트

15장. 케이스 클래스와 패턴 매치

15.1 간단한 예

• 케이스 클래스 : 클래스 선언에서 case 수식자를 넣음
  1. 컴파일러는 클래스 이름과 같은 이름의 팩토리 메소드를 추가한다. new 없이 객체를 생성할 수 있다.
  
  2. 파라미터 목록에 있는 모든 클래스 파라미터에 암시적으로 val 접두사를 붙인다. 각 파라미터가 클래스의 필드도 된다.
  3. toString, hashCode, equals 메소드의 자연스러운 구현을 추가한다.
  4. 컴파일러는 케이스 클래스에서 일부를 변경한 복사본을 생성하는 copy 메소드를 추가한다.

abstract class Expr
case class Var(name: String) extends Expr
case class Number(num:  Double) extends Expr
case class UnOp(operator: String, arg: Expr) extends Expr
case class BinOp(operator: String, left: Expr, right: Expr) extends Expr

object HelloWorld {
    def main(args: Array[String]) {
        val v = Var("x")
        val op = BinOp("+", Number(1), v)
        
        println("v.name : " + v.name)
        println("op.left : " + op.left)
        
        println("op : " + op)
        println("op.right == Var(x) : " + (op.right == Var("x")))
        
        val op2 = op.copy(operator = "-")
        println("op.copy(operator = -) : " + op2)     
        println("op == op2 : " + (op == op2))
    }
}

[결과]
v.name : x
op.left : Number(1.0)
op : BinOp(+,Number(1.0),Var(x))
op.right == Var(x) : true
op.copy(operator = -) : BinOp(-,Number(1.0),Var(x))
op == op2 : false

• 패턴 매치

  • 셀렉터 match { 대안들 }
  • 패턴 매치에는 case 키워드로 시작하는 대안들이 들어가고 각 대안은 패턴과 => 심볼로 분리되는 패턴과 일치했을 때 계산할 표현식으로 구성된다.

• switch와 match의 비교
  1. 스칼라의 match는 표현식이고 결과 값을 내놓는다.
  2. 스칼라의 case는 다음 case로 빠지지 않는다. (break 불필요)
  3. 매치에 성공하지 않는 경우 MatchError 예외가 발생하므로 디폴트 케이스를 반드시 추가해야 한다.

val t = "a"
t match {
    case "b" => println("b")
}
[결과]
Exception in thread "main" scala.MatchError: a (of class java.lang.String)

15.2 패턴의 종류

• 와일드카드 패턴 : 어떤 객체라도 매치할 수 있고 어떤 객체에서 값을 알 필요가 없는 부분을 무시하기 위해 사용한다.

def matchTest(arg: Expr){
    arg match{
        case BinOp(_, _, _) => println(arg + " is a binary operation")
        case _ => println("It's somethisng else")
    }
}

matchTest(op)
matchTest(v)

[결과]
BinOp(+,Number(1.0),Var(x)) is a binary operation
It's somethisng else

• 상수 패턴 : 자신과 똑같은 값과 매치되며 어떤 종류의 리터럴이든 상수로 사용할 수 있다.

• 변수 패턴 : 와일드카드처럼 어떤 객체와도 매치되나 변수 객체를 바인딩한다.

• 변수 또는 상수?

  • 소문자로 시작하는 이름은 패턴 변수로 취급하고 다른 모든 참조는 상수로 간주한다.
  • 디폴트 케이스를 추가 시 컴파일 에러 발생(Warning 발생하는 듯)
  • 소문자 이름을 상수 패턴으로 사용하고 싶다면 긴 이름을 사용하거나 역따옴표를 사용해 변수 이름을 감싸면 된다

• 생성자 패턴 : 어떤 값이 해당 케이스 클래스에 속하는지 검사한 다음 그 객체의 생성자가 인자로 전달받은 값들이 괄호 안의 패턴과 정확히 매치될 수 있는지 검사하는 것으로 스칼라 패턴이 깊은 매치를 지원한다는 뜻이다.

def deepMatchTest(expr: Expr){
      expr match {
        case BinOp("+", Number(1), v) => println("a deep match")
        case _ => println("no match")
      }
}

val opA = BinOp("+", Number(1), v)
val opB = opA.copy(operator = "-")
val opC = BinOp("+", Number(0), opA)
deepMatchTest(opA)
deepMatchTest(opB)
deepMatchTest(opC)

[결과]
a deep match
no match
no match

• 시퀀스 패턴 : 배열이나 리스트 같은 시퀀스 타입에 대해서도 매치시킬 수 있으며 패턴 내부에 원하는 개수만큼 원소를 명시하고 길이를 한정하지 않고 매치할 수 있다.

expr match{
    case List(0, _, _) => println("found it")
    case List(0, _*) => println("found it")
    case _ =>
}

• 튜플 패턴 : 튜플도 매치 가능 (case(a, b, c) => println("matched" + a + b + c))
• 타입 지정 패턴 : 타입 검사나 타입 변환을 대신하기 위해 사용되며 특히 타입 검사와 변환을 동시에 사용해야 한다면 유용하다.

def fun(x: Any) = x match {
    case s: String => s.length
    case m: Map[_, _] => m.size
    case _ => -1
}
위와 같은 동작을 isInstanceOf[typeVal] 와 asInstanceOf[typeVal] 호출할 경우 코드가 더 길어지고 복잡해짐

• 스칼라는 자바와 마찬가지로 제네릭에서 타입 소거 모델을 사용하기 때문에 match를 통해 원소 타입 확인이 어렵지만 배열은 원소 타입과 값을 함께 저장하므로 가능하다.
• 변수 바인딩 : @ 기호를 넣고 패턴을 쓰면 일반적인 매치를 시도하고 그 패턴 매치에 성공하면 변수가 하나 있는 패턴에서처럼 매치된 객체를 변수에 저장한다.

15.3 패턴 가드

패턴 뒤에 오고 if로 시작하며 패턴 안에 있는 변수를 참조하는 어떤 불리언 표현식도 가드로 사용할 수 있다. 가드가 있으면 가드가 true가 될 때만 매치에 성공한다.

case n: Int if 0 < n => ...  // 양의 정수만 매치
case s: String if s == 'a' => ... // 'a'문자로 시작하는 문자열만 매치

15.4 패턴 겹침

case문의 순서가 중요하며 모든 경우를 처리하는 case문의 위치가 상위에 있을 경우 컴파일러가 경고 표시를 한다. (error : unreachable code)

15.5 봉인한 클래스

• 최상위 슈퍼 클래스 앞에 sealed 키워드를 선언하여 그 클래스와 같은 파일이 아닌 다른 곳에서는 새로운 서브 클래스를 만들 수 없도록 한다.
• 봉인한 클래스는 패턴 매치에서 유용하며 컴파일러가 경고 메시지와 함께 놓친 패턴 조합을 환기시켜준다.
• 매치의 셀렉터에 @unchecked 애노테이션을 추가하면 컴파일러가 case문이 모든 패턴을 다 다루는지 검사하는 것을 생략하여 놓친 패턴에 대한 경고 메시지를 안 볼 수 있다.

15.6 Option 타입

• Option이라는 표준 타입은 선택적인 값을 표현하며 값이 있을 경우 Some(x), 없으면 None이라는 객체가 된다.
• 스칼라 컬렉션의 몇몇 표준 연산은 선택적인 값을 생성하고 이 옵션 값을 분리하는 일반적인 방법은 패턴 매치이다.

val capitals = Map("France" -> "Paris", "Japan" -> "Tokyo")
println("capitals get France : " + (capitals get "France"))         // capitals get France : Some(Paris)
println("capitals get North Pole : " + (capitals get "North Pole")) // capitals get North Pole : None

def show(x: Option[String]): String = {
    x match {
        case Some(s) => s
        case None => "????"
    }
}
println("capitals get France : " + show(capitals get "France"))         // capitals get France : **Paris**
println("capitals get North Pole : " + show(capitals get "North Pole")) // capitals get North Pole : **????**

• null이 반환되지 않기 때문에 변수를 사용할때 마다 null 검사를 하지 않아도 되고 NullPointerException을 발생하지도 않는다. option 사용으로 인해 null이 될 수 있는 변수를 사용하는 프로그램에서 스칼라는 타입 오류를 발생한다. 어떤 변수가 Option[String] 타입이라면, 그 변수를 String으로 사용하려 하는 스칼라 프로그램은 컴파일을 할 수 없다.

val optionSize = (capitals get "France").length()  // **Compile Error : value length is not a member of Option[String]**
val noralsize = (show(capitals get "France")).length()

15.7 패턴은 어디에나

• 변수 정의에서 패턴 사용하기 : val이나 var를 정의할 때, 패턴을 사용. 케이스 클래스와 같이 사용하며 패턴을 사용해 값일 해체할 수 있다.

val exp = new BinOp("%", Number(5), Number(1))
val BinOp(opr, left, right) = exp
println("opr : " + opr + ", left : " + left + ", right : " + right)

16장. 리스트

16.1 리스트 리터럴

• 배열과 비슷하나 변경이 불가능하고 재귀적이다. (예 : linked list)

16.2 리스트 타입

• 리스트 타입은 공변적이다.
• 빈 리스트의 타입이 List[Nothing]이며 Noting은 클래스 계층구조의 맨 아래 타입이므로 List()는 List[String] 타입이기도 하다.

16.3 리스트 생성

• Nil은 빈리스트를 의미하고 ::는 리스트의 앞에 원소를 추가한다.

val nums: List[Int] = List(1, 2, 3, 4)
val nums = 1 :: 2 :: 3 :: 4 :: Nil

16.4 리스트 기본 연산

• head : 리스트의 첫번째 원소
• tail : 리스트의 첫번째 원소를 제외한 나머지 원소로 이뤄진 리스트
• isEmpty : 리스트가 비어 있다면 true를 반환

16.5 리스트 패턴

패턴 매치를 사용해 각 부분으로 나눌 수 있다.

val fruit: List[String] = List("apple", "orange", "pear", "melon", "grape")
val a :: b :: rest = fruit
println("a : " + a)
println("b : " + b)
println("rest : " + rest)

[결과]
a : apple
b : orange
rest : List(pear, melon, grape)

16.6 List 클래스의 1차 메소드

• 두 리스트 연결하기 : ":::" 두 인자를 리스트로 받아 연결한다.
• 분할 정복 원칙 : ??
• 리스트 길이 구하기: length - 리스트를 순회하여 검사하기 때문에 원소 개수만큼 시간이 걸린다.
  1. 리스트 양 끝에 접근하기: init, last (head 및 tail과 달리 계산하기 위해 전체 리스트를 순회한다.)
     init : 마지막 원소를 제외한 모든 원소를 포함한 리스트를 반환
     last : 마지막 원소를 반환
     
  2. 리스트 뒤집기: reverse 리스트의 뒤집어 새로운 리스트를 생성한다.
     
  3. 접두사와 접미사: drop, take, splitAt
     drop : 첫번째에서 n번째까지 원소를 제외한 리스트 원소들 반환
     take : n 번째까지 원소를 반환
     splitAt : n번째 인덱스 위치에서 리스트를 분할하여 반환
     
  4. 원소 선택: apply와 indices
     apply : n 번째 인덱스 원소를 반환
     indices : 유효한 모든 인덱스의 리스트를 반환
     
  5. 리스트의 리스트를 한 리스트로 반듯하게 만들기: flatten
     flatten : 리스트의 리스트를 인자로 받아서 하나의 리스트로 반듯하게 펼친다.
     
  6. 두 리스트를 순서쌍으로 묶기: zip과 unzip
     zip : 두 리스트를 인자로 받아서 순서쌍의 리스트를 만들면 길이가 다르면 긴 쪽의 남는 원소를 버린다.
     zipWithIndex : 리스트의 모든 원소와 그 위치를 묶는다.
     unzip : 튜플의 리스트를 리스트릐 튜플로 바꾼다.
     
  7. 리스트 출력하기: toString, mkString
     toString : 리스트에 대한 표준 문자열 표현을 반환
     mkString : 접두사 문자열, 분리 문자열, 접미사 문자열을 받아 문자열로 반환
     addString : mkString과 유사하나 StringBuilder객체에 추가
     
  8. 리스트 변환하기: iterator, toArray, copyToArray
     iterator : 리스트 원소를 이터레이터를 사용해서 접근
     toArray, toList : List <-> Array 변환
     copyToArray : 리스트 원소를 배열의 특정 지점부터 연속적으로 복사
     

16.7 List 클래스의 고차 메소드

1. 리스트 매핑: map, flatMap, foreach
   map : 리스트를 함수에 적용하여 그 결과 값으로 이뤄진 리스트를 반환
   flatMap : map과 유사하나 결과 리스트를 서로 연결한 하나의 리스트로 반환
   foreach : 오른쪽 피연산자로 프로시저를 받아 적용
   
2. 리스트 걸러내기:filter, partition, find, takeWhile, dropWhile, span
   filter : Boolean 타입의 술어 함수를 받아서 true인 원소의 리스트를 반환
   partition : filter와 같이 술어 함수를 받아서 true, false 각 리스트로 반환
   find : filter와 유사하나 술어 함수에 만족하는 첫 번째 원소만 반환
   takeWhile : 술어 함수를 만족하는 가장 긴 접두사를 반환
   dropWhile : 술어 함수를 만족하는 가장 긴 접두사를 제거
   span : takeWhile, dropWhile을 하나로 묶은 것
   
3. 리스트 전체에 대한 술어: forall과 exists
   forall : 모든 원소가 술어 함수를 만족할 때 true를 반환
   exists : 술어 함수를 만족하는 원소가 하나라도 존재하면 true를 반환
   
4. 리스트 폴드: /:, :<br/> fold연산 : 왼쪽폴드 /: 오른쪽 폴드 :\ 전달받는 연산자를 각 방향으로 부터 연속 적용
   
5. 리스트 정렬: sortWith
   sortWith : List sortWith before 형식으로 before 자리에 정의된 비교함수대로 정렬 (예 : ListX sortWith (_ < _))
   

16.8 List 객체의 메소드

1. 원소로부터 리스트 만들기: List.apply
   List.apply : List.apply(1,2,3) == List(1, 2, 3)
   
2. 수의 범위를 리스트로 만들기: List.range
   List.range : 어떤 범위를 구성하는 수로 이루어진 리스트를 만든다. List.range(from, until, increment)
   
3. 균일한 리스트 생성: List.fill
   List.fill : 생성할 리스트의 길이와 반복할 원소를 받아 리스트를 채움 (예 : List.fill(5)('a'), List.fill(2,3)('b'))
   
4. 함수 도표화:List.tabulate
   List.tabulate : 제공된 함수로 계산한 원소의 리스트를 생성 (예 : List.tabulate(5)(n => n * n), List.tabulate(5,5)(*))
   
5. 여러 리스트 연결하기: List.concat
   List.concat : 여러 리스트를 연결한다. (예 : list.concat(List(), List('a'), List('b'))

16.9 여러 리스트를 함께 처리하기