IT & Mobile

특성

1. immutable    (Array는 mutable)

2. recursive 지원 (Arrary는 미지원)

3. covariant  -   if S is subtype of T이면   List[S]도 List[T]의 subtype.

     =>  이로 인해, List() (List[Nothing])  이 List[S나 T]의 subtype 이 된다.

head와 tail

  - head는 첫 아이템이고 tail은 나머지 모든 아이템.

List 생성

 $ val abc: List[String] = List("a","b","c")

 $ val fruit = "ora" :: "pea" :: "apples" :: Nil     (이 경우에는 Nil이 꼭 필요)

패턴지정 (위에서 fruit가 지정되어 있는 경우)

 $ val List(a,b,c) = fruit     이런형태로 지정해서 a,b,c 를 자동 입력도 가능 (a="ora"가 됨)

:: (cons 연산자)

 - scala내의 class로도 존재하고, List내의 method로도 존재.

   (class로 존재하기 때문에  x :: xs 가 ::(x,xs) 로 취급됨.

scala 싱글턴 Object  (즉, 키워드 object)

는 2가지 용도로 쓰인다.

1.  Companion Object

- scala class에는 static 함수를 포함할 수 없기 때문에, class 와 동일한 Object 이름을 이용해서

static 함수를 모아 놓는다. 

class A(msg:String){

   def greet() = println(msg)

}

object A{

  def trim(s:String) = s..blabla

}

2. stand-alone Object.    

 - 이건 제일 자주보는 main을 포함하기 위한 용도이다.

object myApp {

  def main( args: Array[String]) {

  }

}

1. Nil은  List 가   비어있을 때.를 Nil이라고 한다.

$ val a=List()

$ a==Nil      ==>    true 임.

2. Nothing은 최하위 class 이다.  

  아래 예제에서 else 경우에 Nothing이 리턴된다. (Int 의 Subtype이므로 리턴 가능.) 

  def divide(x:Int, y:Int) :Int =  if (y!=0) x/y  else error("hi Error")

    =>  이경우에 Nothing이...   인터프리터에서 돌려보니 deprecation 된 거 같기도 한데.. (추가 확인 필요) 

3. Null은 기존 java Null 하고 비슷하니 개념은 잠시 잊어도 되겠다.

<Hierarchy>

java.lang.Object 에 해당하는 건  scala.AnyRef 이다.

Scala에선 Any가 최상위 클래스 이고..

data Type 들은 왼쪽 AnyVal 트리를 타게 되므로..

아래 계층도와 같다.

            Any

          /     |    

AnyVal   AnyRef

      |         |

Type들    AnyObject

      |         |

      |       Null 

      |        /

     Nothing

 ($: scala line interpreter 라고 치고.....)

기본 def:

$def h(x:String):Type = { println(x)}

1. 한 줄 일때는 curly brace 생략 가능

$def  h() = println("hi")

$def  h = println("hi")    (이것도 동일 동작.)

  => 이 때 아무동작 안하는 듯한 return type은 Unit이라고 부름 (java 의 void 와 비슷)

2. retrurn Type은 보통 안 붙여도 자동추론 하지만. recursive일 때는 꼭 필요.

3. def this     :    추가 생성자용도이다.   (overloaded constructor or Auxilary constructor 라고 부른다) 

   primary 생성자는 자동생성되므로..아래 예제처럼 추가 생성자를 생성할때  this함수와 함께 사용할 수 있다.

 class Test( msg:String, count:Int) {

    def this (msg:String ) = this (msg,1)

 }    

  hello.scala 내용:  println(" Hello world")

1. hello.scala와 같은 script 작성 후  

$ scala hello.scala 로 실행 .

2. class나 object .scala작성후

$scalac co.scala

$scala co   

하면 되는데

scalac 보다 빠른 fsc (fast scala compiler)가 존재한다.

차이점은 fsc는 항상 메모리에 띄워 놓고, scalac은 JVM을 그 때 그때 띄우게 되는데..

따라서 fsc를 죽이고 싶다면 

$ fsc co.scala

$ scala co 

$ fsc - shutdown  으로 죽이면 된다.

class

- java의 class와 동일하다고 보면 되나, primary 생성자는 없다.

- primary 생성자는 class Dog(legs:Int, name:String){ } 로 정의에서 끝난다.

=> legs,name은 val로 자동생성된다.

- primary생성자의 body는 class 안에 아무데나 쓰면 된다.

- overload 생성자는 def this(legs:Int)와 같은식으로 명시하면 된다.

object

- companion object와 stand_alone object 가 존재한다.

- companion object는 java의 static함수를 모아놓은 것이라고 생각하면 된다.
  동일한 이름의 class가 존재한다.

- stand alone object는 독립적으로 존재하는데 보통
  def main(args:Array[String]) {  } 을 포함하는 용도로 사용된다. 

trait

- java의 interface와 유사하다고 보면되나, implements 키워드 대신 항상 extends키워드를 쓴다.

- method를 구현할 수 있다. (java Interface도 원래는 abstract함수만 되나, 1.8부터 body구현 지원)

- 인스턴스 생성시에 with 키워드로 바로 적용이 가능하다. (복잡하겠군요.. 인스턴스마다 다른 특성을 지니겠네요)

- extends Trait  해서 함수 오버라이드 시에..  def 앞에 override 키워드 꼭 필요.

class 인스턴스의 접근성

- class Dog{ var sum=0 }  일 경우 val a = new Dog 이 안됨.  단 var a일 경우.. a.sum+=1 은 됨.  

- class Dog{ private sum=0} 일 경우 val a = new Dog이 됨. s.sum +=1 이 안됨.

def의 접근성. =이 type을 의미함.

scala> def h = {"hello"}    h는 hello String 리턴.

scala> def g {"hello"}    g는 리턴없음. 즉 Unit리턴.

scala> def f:Unit = "hello"    g와 동일. 

Array: mutable이고  java와 달리, (0),(1)로 마치 함수호출 하듯이 element get함.

List : immutable이고 동일한 type을 보관

tuple: immutable이고 서로 다른 type의 데이타를 저장할 수 있다. 

HashSet, HashMapt: mutable   (Set,Map은 trait임)

예) val s = new HashSet[String] 

    s += "AA"

예) val m = new HashMap[Int, String]

    m += (1 -> "Go to Hell") 

<immutable Set/Map> - factory method방식으로 이용가능.

    예) val s = Set("A", "BB", "CC")            : compoiler transfers as Set.apply()

   예) val s = Map(1 -> "AA", 2->"BB")       : compoiler transfers as Map.apply()

요약하면 immutable List,Tuple,  Set,Map이 존재한다.

1. io.Source.stdin 이용    REF-SITE

   for (ln <- io.Source.stdin.getLines) println(ln)  

   (참고: break나 return이 잘 안되서 study 중 )

  1.5 위에서 stdin = fromInputStream(System.in)으로 def(ine)되어 있다. 따라서 아래처럼 변형도 가능

    val input = Source.fromInputStream(System.in);

   val lines = input.getLines.collect

2. System.in 에서 읽기

=> readLine()함수가 system.in에서 바로 라인을 읽는다.

끝나면 null을 리턴하므로 체크 필요.

object SysteminTest {
  def main(args: Array[String]) {
var line = true
do {
  var str = readLine()                    //depricated.. 
  if (str!=null) println(str)
  else line=false   //need test..
} while ( line )

  }
}  

2. File에서 읽기

Line을 읽어서 String으로 만드는데,  empty Line을 공백" " 으로 처리하는 방법.

val file = Source.fromFile(args(0)).getLines().filter(!_.isEmpty()).mkString(" ")

scala에서 DB를 연동할 때, JDBC를 직접 사용할 수도 있지만

Play Framework와 함께 할때는 Anorm을 사용하는 방법이 편리하다.

REF-SITE :play

사용모습을 보면 아래와 같다.

(예제: 출처 https://janhelwich.wordpress.com/tag/anorm/ )

Scala를 이용해서 OO를 TEST.

(OO Test using Scala)

object Seminar{


  class Dog(a:Int, n:String){
    var age:Int = a
    var name:String = n

    def feed()={
      println(this.name+ ":eating dog food")
    }
  }


  class Cat(a:Int, n:String) extends Dog(a:Int, n:String){
    override def feed()={
      println(this.name+ ":eating Cat food")
    }
  }


  ////////  MAIN  ////////////////////////////////////////////////
  def main(args:Array[String]) = {
   var allDog:Array[Dog]   = Array( new Dog(1,"dogA"),
     new Dog(2,"dogB"),
     new Dog(3,"dogC"),
     new Dog(4,"dogD"),
     new Cat(5,"catA"))


    for( dog<- allDog)
      dog.feed()

  }
} //end

Actor is Thread+Queue, while

Future provide a way to reason about performing many operations in paralle

   http://la-stranger.tistory.com/m/post/entry/Scala-Future-Tutorial

전통적인 consumer/supplier 예제를 간단히 변형해서

2개의 은행에서 각자 고객 수자를 관리하다가

전체 고객의 합을 구하는 형태를 문제가 있게 OLD한 방법으로 일부러 작성해보면 다음과 같다.

///////////////////////////////////////////////////////////////

  class Bank {
    var numKid:Int = 0
    var numAdult:Int = 0
    var numAged:Int = 0

    def addNum (k:Int,a:Int,g:Int) = {
      numKid += k
      numAdult += a
      numAged += g
      Main.totalKid += numKid   //no need on FP
      Main.totalAdult += numAdult
      Main.totalAged += numAged
    }

  }

////global FOR: Bank Sum total : OLD ///////////////
var totalAll:Int = 0 //NO NEED on FP
var totalKid:Int = 0
var totalAdult:Int = 0
var totalAged:Int = 0
 
// main
def main(args:Array[String]) = {

  //// Bank Sum total :OLD ///////////////
  val actorBank1 = actor {
    val bank1 = new Bank
    while (true) {
      bank1.addNum(0, 1, 0)
      Thread.sleep(10)
    }
  }

  val actorBank2 = actor {
    val bank2 = new Bank
    while (true) {
      bank2.addNum(2, 2, 1)
      Thread.sleep(10)
    }
  }

  //WHEN WANT TO PRINT
  while (true) {
    //SUM
    Main.totalAll = Main.totalKid + Main.totalAdult + Main.totalAged  //SUM

    //NO MATCH?
    if( totalAll != (totalKid+totalAdult+totalAged))
      println("total:" + totalAll + ", Kid:" + totalKid + ", Adult:" + totalAdult + ", Aged:" + totalAged)

    Thread.sleep(20)
  }
 
 
 
이게 돌다보면 totalALL합이 맞지 않는 경우가 자주발생하도록 한 코드인데..
FP 스타일로 바꿔보면 다음과 같다.
 
 
 
================================>  FP Style  로 전환
 
 
1. 가능하면 tuple을 이용
2. 전체적인 합 같은 totalAll 같은 변수를 아예 없앤다.
(그 외에  좀 더 sum2Bank같은 함수를 sum리턴안하게 좀 하고 싶은데.. 연구 중.)
 

class Bank {
  var numKAG = (0,0,0)

  def addNum (k:Int,a:Int,g:Int):Unit = {
    numKAG = (numKAG._1 + k, numKAG._2 + a, numKAG._3 + g)
  }
}

def sum2Bank (b1:Tuple3[Int,Int,Int], b2:Tuple3[Int,Int,Int] ) = {
  val sum = ( b1._1 + b2._1, b1._2 + b2._2, b1._3 + b2._3 )
  sum
}

def main(args:Array[String]) = {

  //// Bank Sum total :OLD ///////////////
  val bank1 = new Bank
  val bank2 = new Bank

  val actorBank1 = actor {
    while (true) {
      bank1.addNum(0, 1, 0)
      Thread.sleep(10)
    }
  }

  val actorBank2 = actor {
    while (true) {
      bank2.addNum(2, 2, 1)
      Thread.sleep(10)
    }
  }


  //WHEN WANT TO PRINT
  while (true) {
    //SUM
    val sum = sum2Bank(bank1.numKAG, bank2.numKAG)
    val totalAll = sum._1 + sum._2 + sum._3

    //Always MATCH cause there is no toalALL variable
    if( totalAll != (sum._1 + sum._2 + sum._3))
      println("total:" + totalAll + ", Kid:" + sum._1)


    Thread.sleep(20)
  }


}
 
 

 

참고사이트:

var (x,y,z) = (1,2,3)    //튜플 선언

(1 to 5).map( 2 * )     // Vector(2,4,6,8,10)임.   2 * _ 에서 마지막에 _은 생략 가능    

import java.util.Date    //java도 import 해서 사용가능

1 :: List(2,3)             // List(1,2,3) 과 동일  연결연산자cons

(1 to 5)         // Range(1, 2, 3, 4, 5)

(1 until 6)       // Range(1, 2, 3, 4, 5)

(1 to 10 by 2)  // Range(1, 3, 5, 7, 9)

_ > 4             // v => v > 4 와 같은 predicate 임.

<FP 기법>

1. carry Over  :  tail recursive 처럼 결과값을 계속 넘기는 방식. (carry Over: 그냥 영어임.)  

2. predicate : 함수는 f()로 표현. Boolean을 리턴하는 함수는 predicate 이라고 부름.
       (이것도 scala에선 그냥 영어임. java엔 Predicate존재) 

=> p()를 이용해  함수 input  param들을 필터처럼 거를 수 있음

<FP기법 예제 - 1.carryOver>

object Main{

  def total(list: List[Int]) = { //기존 sum함수
    var sum = 0
    for (i <- list) { sum += i }
    sum
  }

  def totalFP(list:List[Int]) = { //부분합을 계속 넘기면서 합을 해나가는 방식.  foldLeft함수가 첫번째 param으로 carryOver로 계속 받아 주면서 iterate를 제공.
    list.foldLeft(0) { (carryOver,v) => carryOver + v }
  }

  def main(args:Array[String]) = {
    println(totalFP(List(1,2,3,4,5)))
  }
}

<FP기법 예제 - 2.Predicate>

def totalFP(list:List[Int] , p:Int => Boolean) = {
  list.foldLeft(0) { (carryOver,v) => if (p(v)) carryOver + v else carryOver }
}

def main(args:Array[String]) = {
  println(totalFP(List(1,2,3,4,5),{ v => v % 2 == 0 }))   //짝수인 2,4 만 적용되서 합이 6 이 나옴.
}
  추가적으로  v => v > 4 같은 predicate은  _ > 4 로 표시 가능

그리고 아래 3가지들이 scala에서 좀 특별하다.

trait -  java의 Interface와 비슷하지만, class특성도 지님.

   <trait특성 >

     - extends 로도 with 로도 사용가능하다. 심지어는 구현body가 존재해도 된다.

     - with의 경우에는 여러가지 trait가 사용가능하며, with A, with B의 경우 B가 먼저 적용된다.

     - override abstract라는 키워드를 사용하여 기존 def를 추상화하여 사용할 수도 있다.

     - Class 가 아니고 인스턴스에도 사용가능 : with Friends

xml - xml이 1등급 고객임. "" 필요없음

actor - thread + 큐 : 수천개의 actor를 만들어도 된다

자세한 건 여기클릭: hillarious indian guy

scala로 EOP (Expression Oriented Programming)을 하기에 좋다.

http://alvinalexander.com/scala/best-practice-think-expression-oriented-programming-eop 

<<

JAVA:  bytecode는 interpre언어이나.. 실행시 JIT Compiler가 기계어로 바꿔서 실행하므로 compile언어라고 본다.

Scala는 이와 동일하게 javabytecode로 바꾸는 방식을 그대로 따르며, 완전한 java bytecode를 이용한다.   >>

이름에서 나와있듯이 scalable한 언어이다.

아래 1번 scalable이 6번 안전성과 관계를 좀 더 살펴봐야 할 것 같은데

어쨌던 Functional 언어의 등장 자체가

multi-core에서 안전성을 가지기 위해서 이므로..

6번의 안전성을 기반으로 1번 확장성도 가지게 된다고 개인적으로 보고 있다.

<Scala의 특징>

1. scalable

2. pure Object-Oriendted  (java는 primitive가 Object가 아님)

3. Functional 언어

- Assignment를 없애서, 참조투명성(REFERENTIAL TRANSPARENCY) 을 확보.

참고사이트:

4. Java 호환.

5. 함수도 객체.

6. future-Proof

7.Fun 

참고사이트:

한글 튜토리얼

< 기본 문법>

def : function이나 method를 선언할때 사용 

val : reasign이 불가능한 상수를 선언할때 사용 

var: reasign이 가능한 변수를 선언할때 사용 

exam )

    def helloWorld = println("hello world.") 

    val foo: Int = 1 

    var bar = "test" 

<case Class>

new 없이 쓸 수 있고,  getter필요없이 바로 .value 로 access.

Several Example : http://alvinalexander.com/scala/ 

<Flat Map>

http://alvinalexander.com/scala/collection-scala-flatmap-examples-map-flatten