코세라 Scala 강의 중 MergeSort 예제에서 조금 이해하기 쉽게 분리한 예제이다.

https://www.coursera.org/learn/progfun1/lecture/0uFfe/lecture-5-2-pairs-and-tuples

object MergeSort {
  def merge(left: List[Int], right: List[Int]): List[Int] = (left, right) match {
    case (l, Nil) => l
    case (Nil, r) => r
    case (leftHead :: leftTail, rightHead :: rightTail) =>
      if (leftHead < rightHead) leftHead::merge(leftTail, right)
      else rightHead :: merge(left, rightTail)
  }

  def mergeSort(list: List[Int]): List[Int] = {
    val n = list.length / 2
    if (n == 0) list
    else {
      val (left, right) = list splitAt n
      merge(mergeSort(left), mergeSort(right))
    }
  }
}

결과

Int 타입을 T 타입으로 (order:(T, T) => scala.Boolean)을 추가해서 compare를 할 수 있게 한다.

object MergeSort {
  def mergeSort[T](list: List[T])(order: (T, T) => scala.Boolean): List[T] = {
    val n = list.length / 2
    if (n == 0) list
    else {
      def merge(left: List[T], right: List[T]) : List[T] = (left, right) match {
        case (l, Nil) => l
        case (Nil, r) => r
        case (leftHead :: leftTail, rightHead :: rightTail) =>
          if (order(leftHead, rightHead)) leftHead::merge(leftTail, right)
          else rightHead :: merge(left, rightTail)
      }
      val (left, right) = list splitAt n
      merge(mergeSort(left)(order), mergeSort(right)(order))
    }
  }
}

object Main extends App {
  println(MergeSort.mergeSort(List(100,50,120,19))((x: Int, y: Int) => (x < y)))
  println(MergeSort.mergeSort(List(100,50,120,19))((x: Int, y: Int) => (x > y)))
  println(MergeSort.mergeSort(List("samuel","jack","juno","ben"))((x: String, y: String) => (x.compareTo(y) < 0)))
  println(MergeSort.mergeSort(List("samuel","jack","juno","ben"))((x: String, y: String) => (x.compareTo(y) > 0)))
}

결과는 다음과 같다.

언제나 스칼라는 타입을 숨길 수 있다.

List(100,50,120,19))((x, y) => (x > y))

여기에 math.Ordering을 임포트해본다.

import math.Ordering
object MergeSort {
  def mergeSort[T](list: List[T])(order: Ordering[T]): List[T] = {
    val n = list.length / 2
    if (n == 0) list
    else {
      def merge(left: List[T], right: List[T]) : List[T] = (left, right) match {
        case (l, Nil) => l
        case (Nil, r) => r
        case (leftHead :: leftTail, rightHead :: rightTail) =>
          if (order.lt(leftHead, rightHead)) leftHead::merge(leftTail, right)
          else rightHead :: merge(left, rightTail)
      }
      val (left, right) = list splitAt n
      merge(mergeSort(left)(order), mergeSort(right)(order))
    }
  }
}

object Main extends App {
  println(MergeSort.mergeSort(List(100,50,120,19))(Ordering.Int))
  println(MergeSort.mergeSort(List(100,50,120,19))(Ordering.Int))
  println(MergeSort.mergeSort(List("samuel","jack","juno","ben"))(Ordering.String))
  println(MergeSort.mergeSort(List("samuel","jack","juno","ben"))(Ordering.String))
}

결과는 이전과 동일하다. 

여기에 implicit을 추가해본다. 그리고 implicit을 쓰면 적당히 코드 삭제가 가능하다.

import math.Ordering
object MergeSort {
  def mergeSort[T](list: List[T])(implicit order: Ordering[T]): List[T] = {
    val n = list.length / 2
    if (n == 0) list
    else {
      def merge(left: List[T], right: List[T]) : List[T] = (left, right) match {
        case (l, Nil) => l
        case (Nil, r) => r
        case (leftHead :: leftTail, rightHead :: rightTail) =>
          if (order.lt(leftHead, rightHead)) leftHead::merge(leftTail, right)
          else rightHead :: merge(left, rightTail)
      }
      val (left, right) = list splitAt n
      merge(mergeSort(left), mergeSort(right))
    }
  }
}

object Main extends App {
  println(MergeSort.mergeSort(List(100,50,120,19)))
  println(MergeSort.mergeSort(List(100,50,120,19)))
  println(MergeSort.mergeSort(List("samuel","jack","juno","ben")))
  println(MergeSort.mergeSort(List("samuel","jack","juno","ben")))
}

역시 결과가 동일하다.

function value의 확장은 스칼라의 기초 지식이다. 

https://twitter.github.io/scala_school/ko/basics2.html

apply 개념은 다음 예제를 살펴본다. 

아래 익명 함수(function value)는 아래 익명 클래스로 확장(expand)된다.

또는 

익명 클래스 2) 

coursera의 강의 Functional Programming Principles in Scala 4장 강의 중에 Funtional 언어의 특징을 유난히 보였던 예제가 있어서 끄적거려 봤다..

abstract class Boolean {
  def ifThenElse[T](t: => T, e: => T): T

  def unary_! : Boolean = ifThenElse(False , True)

  def && (x: => Boolean): Boolean = ifThenElse(x, False)
  def || (x: => Boolean): Boolean = ifThenElse(True, x)

  def == (x: Boolean): Boolean = ifThenElse(x, x.unary_!)
  def != (x: Boolean): Boolean = ifThenElse(x.unary_! , x)

  def < (x: Boolean): Boolean = ifThenElse(False, x)
  def > (x: Boolean): Boolean = ifThenElse(x, False)

}

object False extends Boolean {
  def ifThenElse[T](t: => T, e: => T) = e
}

object True extends Boolean {
  def ifThenElse[T](t: => T, e: => T) = t
}

테스트 결과

True.ifThenElse(println("yes"), println("no"))       // yes
False.ifThenElse(println("yes"), println("no"))      // no
(! True).ifThenElse(println("yes"), println("no"))   // no
(! False).ifThenElse(println("yes"), println("no"))   // yes

println
(True && False).ifThenElse(println("yes"), println("no"))  // no
(True && True).ifThenElse(println("yes"), println("no"))  // yes
(False && True).ifThenElse(println("yes"), println("no"))  // no
(False && False).ifThenElse(println("yes"), println("no"))  // no

println
(True == True).ifThenElse(println("yes"), println("no")) // yes
(True && True == True).ifThenElse(println("yes"), println("no")) //yes
(False || True != True).ifThenElse(println("yes"), println("no")) //no

println
(False < True).ifThenElse(println("yes"), println("no")) // yes
(False > True).ifThenElse(println("yes"), println("no")) // no

sbt about와 sbt -v 둘 다 사용해 버전을 확인할 수 있다. 

Scala For Data Science 책에 소개된 json->객체, 객체 ->json 예제로서 내용이 좋아서 조금 수정해봤다.

Repo.scala

Api.scala

conf/routes 파일에 다음을 추가한다.

웹 브라우져에서 http://127.0.0.1:9000/api/repos/odersky을 호출한다. 

결과

Play 프레임워크에서는 Writes[T] 타입 클래스는 단 하나의 메소드를 가진다.

trait Writes[T] {

  def writes(obj:T):Json

}

Writes 메소드는 Play 프레임워크에 내장되어 있어서 Writes를 직접 구현하지 않아도 된다.

Writes[Repo] 인스턴스는 Api controller 코드에서 정의해서 Api controller 내부에서 사용할 수 있도록 한다. 

Writes[Repo] 타입 클래스는 Repo 인스턴스를 JSON으로 변환하는 방법을 안다. JSON HTTP 응답을 생성하는 방법을 알고 있기 때문에 깔끔한 코드를 짤 수 있다.

자바라면 맵/배열을 이용하거나 custom Serializer 를 사용해야 한다(예, http://www.baeldung.com/jackson-map)

이를 편하게 만들어준다고 할 수 있는 큰 기능인 것 같다.

이제는 json을 객체로 변환하는 코드 테스트이다. 

controllers.Api 클래스의 코드를 다음과 같이 변경한다.

https://api.github.com/users/odersky/repos의 코드를 실행해 json 파싱하고 Read[Repo]타입 클래스에 저장하도록 한다. 

spark streaming job을 개발할 때,

streaming이 잘 동작하는데. 문제 없는지 확인하고 싶을 때  

다음 URL을 잘 이용해 본다. spark ui를 

https://docs.cloud.databricks.com/docs/latest/databricks_guide/07%20Spark%20Streaming/02%20Debugging%20Spark%20Streaming%20Application.html

parquet는 성능이 좋은 것으로 알려져 있지만, 일반 텍스트로 볼 수 없다는 단점이 있다..

그러나 기능적으로 봤을 overwrite를 할 수 있다는 점에서.. parquet가 많이 쓰여질 것 같다.

로컬 장비에서 parquet 테스트는 다음처럼 진행 할 수 있다. 

이 코드는 zipWithIndex와 for-yield 문, if문을 잘 설명하는 코드이다. 

occurrencesOf(10, List(0,1,2,3,4,10)) 코드를 설명한다.

collection.zipWithIndex 은 다음과 같은 값을 리턴한다.

((List(0), 0), (List(1), 1), (List(2), 2), (List(3), 3), (List(4), 4), (List(10), 10))

그러다다 elem으로 들어온 10 값을 만나면 관련 index 값 10을 리턴한다. 

spark의 join 예제이다. 

sql의 join과 같은 개념이다. collection과 case class를 활용해 데이터 집합을 하나로 결합할 수 있다. 

case class를 이용할 수도 있다.

만약 필드 중에 null 컬럼 데이터가 있다면, Option을 사용하는 것이 좋은 방법일 것이다.

filter는 dataframe에서 where를 spark sql에서 사용하는데, 

이 둘의 차이가 무엇일까 살펴봤더니..

where는 filter의 앨리어스라 한다.

결국은 아래 함수의 결과는 동일하다.

employee.filter($"age" > 15)

employee.where($"age" > 15)