직접 제가 실행해서 전부 된 내용이니까요. 한번쯤 쭉 돌려 보시면 이해가 되실 듯 합니다.

자 시작 ----

---- 다음 화에 계속..

다음화에서는 OOP라던지 Actor 등을 나열해 보도록 하겠습니다. 그럼 다음 기회에 :)

object HelloWorld {

  def main(args: Array[String]) {

    println("Hello, world! " + args.toList)

  }

}

HelloWorld.main(args)


이렇게 하면 인수도 넣을 수 있네요.


-------------------------------------- 간단한 소스 하나 소개 합니다.

class 부터 어떤 식으로 값을 주고 받는지 볼 수 있겠네요.

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


object Persons {


  /** A list of persons. To create a list, we use Predef.List

   *  which takes a variable number of arguments and constructs

   *  a list out of them.

   */

  val persons = List(

    new Person("Bob", 17),

    new Person("John", 40),

    new Person("Richard", 68)

  )


  /** A Person class. 'val' constructor parameters become

   *  public members of the class.

   */

  class Person(val name: String, val age: Int)


  /** Return an iterator over persons that are older than 20.

   */

  def olderThan20(xs: Seq[Person]): Iterator[String] =

    olderThan20(xs.elements)


  /** Return an iterator over persons older than 20, given

   *  an iterator over persons.

   */

  def olderThan20(xs: Iterator[Person]): Iterator[String] = {


    // The first expression is called a 'generator' and makes

    // 'p' take values from 'xs'. The second expression is

    // called a 'filter' and it is a boolean expression which

    // selects only persons older than 20. There can be more than

    // one generator and filter. The 'yield' expression is evaluated

    // for each 'p' which satisfies the filters and used to assemble

    // the resulting iterator

    for (p <- xs if p.age > 20) yield p.name

  }

}




/** Some functions over lists of numbers which demonstrate

 *  the use of for comprehensions.

 */

object Numeric {


  /** Return the divisors of n. */

  def divisors(n: Int): List[Int] =

    for (i <- List.range(1, n+1) if n % i == 0) yield i


  /** Is 'n' a prime number? */

  def isPrime(n: Int) = divisors(n).length == 2


  /** Return pairs of numbers whose sum is prime. */

  def findNums(n: Int): Iterable[(Int, Int)] = {


    // a for comprehension using two generators

    for (i <- 1 until n;

         j <- 1 until (i-1);

         if isPrime(i + j)) yield (i, j)

  }


  /** Return the sum of the elements of 'xs'. */

  def sum(xs: List[Double]): Double = 

    xs.foldLeft(0.0) { (x, y) => x + y }


  /** Return the sum of pairwise product of the two lists. */

  def scalProd(xs: List[Double], ys: List[Double]) = 

    sum(for((x, y) <- xs zip ys) yield x * y);


  /** Remove duplicate elements in 'xs'. */

  def removeDuplicates[A](xs: List[A]): List[A] =

    if (xs.isEmpty)

      xs

    else

      xs.head :: removeDuplicates(for (x <- xs.tail if x != xs.head) yield x)

}




/** The main class, the entry point of this program.

 */

object Fors {


  def main(args: Array[String]) {

    // import all members of object 'persons' in the current scope

    import Persons._


    print("Persons over 20:")

    olderThan20(persons) foreach { x => print(" " + x) }

    println


    import Numeric._


    println("divisors(34) = " + divisors(34))


    print("findNums(15) =")

    findNums(15) foreach { x => print(" " + x) }

    println


    val xs = List(3.5, 5.0, 4.5)

    println("average(" + xs + ") = " + sum(xs) / xs.length)


    val ys = List(2.0, 1.0, 3.0)

    println("scalProd(" + xs + ", " + ys +") = " + scalProd(xs, ys))

  }


}

역시 콘솔창에서 실행 가능하고요.
scala> Fors.main(null) 이렇게 실행하면

Persons over 20: John Richard
divisors(34) = List(1, 2, 17, 34)
findNums(15) = (4,1) (5,2) (6,1) (7,4) (8,3) (8,5) (9,2) (9,4) (10,1) (10,3) (10
,7) (11,2) (11,6) (11,8) (12,1) (12,5) (12,7) (13,4) (13,6) (13,10) (14,3) (14,5
) (14,9)
average(List(3.5, 5.0, 4.5)) = 4.333333333333333
scalProd(List(3.5, 5.0, 4.5), List(2.0, 1.0, 3.0)) = 25.5

이런 결과가 나옵니다. 여기서 엿 볼 수 있는 것이 각 3개의 Object가 있고 거기서 메인이 되는 것이 한개가 있어서 각 오브젝트를 불러서 사용 하는 방법들이라던지, 여기서 참 재미있는게 하나 있는데
class Person(val name: String, val age: Int) 이 부분인데요 바로 바로 값이 적용되서 들어 갑니다. 꼭 예전에 bean 썻던것처럼 get, set없이 그냥 쏙쏙 들어가네요 :)

소스를 보면서 분석 해 보시기 바랍니다.

그럼 기초부터 설명 들어갑니다.

일단 간단히 콘솔창에서 놀아 볼까요
scala> 1 + 1
res18: Int = 2

scala> val x = "hellO"
x: java.lang.String = hellO

scala> print(x)
hellO
scala> val xl = x.length
xl: Int = 5

scala> res18 * 10
res21: Int = 20

이렇게 계속 뭔가를 가지고 있네요 :) 재미있습니다.
그리고 저 res라는 걸 보니까 아무래도 뭔가 함수를 날렸을 때의 갯수로 해서 하나씩 증가 하는 것 같습니다. 물론 변수로 보관이 되서 나중에라도 끄집어 낼 수 쓸 수 있네요. :) 이런 좋은 것이 :)

scala> import java.util._
import java.util._

scala> val d = new Date
d: java.util.Date = Sat Jul 03 20:28:05 JST 2010

이런 것도 됩니다. 즉 java.util.Date 라는 클래스를 가져와서 바로 쓸 수 있게끔 하는 것도 있고..

아 그리고 콘솔에서 작업을 할 때 보면,

defined module HelloScala
defined class HelloScala

이렇게 나오는게 있는데 말 그대로 입니다 :) 모듈 혹은 class를 정의 했을 때 나오는 거죠. 아마 그 이외에 더 있지 않을까 생각 되는데 일단 현재 하고 잇는 중에는 이 정도만 나오네요.
뭔가 더 재미있는게 슬슬 나올 것 같지 않나요?

그리고 컴파일러 중에 fsc라는 컴파일러가 있는데 아무래도 뜻이 fast scala compiler가 아닐까 하는 생가깅 든다. 이건 정말 빠른 컴파일러라고 하는데 scalac보다 빠르도가 합니다. 그러나 역시 중 대형 규모가 되기 시작하면 ant혹은 maven으로 컴파일러를 관리해야 하니까 그 부분에 대해서도 공부가 필요하다 생각되네요 :)

넘버 관련 형 을 한번 봐 볼까요?
scala> 1.+(2)
res27: Double = 3.0
그냥 바로 더블형으로 나와 주네요 :) 1. 이게 포인트입니다.

이번에는 시간 관련으로 해서 한번 봐 보죠 :)
object Timer {
  def oncePerSecond(callback: () => Unit) {
    while (true) { callback(); Thread sleep 1000 }
  }
  def timeFlies() {
    println("second 1...")
  }

  def main(args: Array[String]) {
    oncePerSecond(timeFlies)
  }
}

이렇게 해 주면 second 1...이게 1초마다 나옵니다.
여기서 timeFlies 이걸 뺄수도 있는데요 다음과 같습니다 :)

object TimerAnonymous {
  def oncePerSecond(callback: () => Unit) {
    while (true) { callback(); Thread sleep 1000 }
  }
  def main(args: Array[String]) {
    oncePerSecond(() =>
      println("second 1..."))
  }
}

역시나 저는 이게 좀 더 보기 좋네요. 이렇게 쓰는 방식을 가지고 무명 펑션(Anonymous functions) 방식이라고 하는 것 같습니다.

이번에는 복합(complex)클래스를 하나 만들어서 여러개의 값을 가지고 있는 클래스를 하나 만들어 볼까 합니다. 이건 예전에 get, set방식인 bean방식 같네요 :) 물론 더욱 더 편해졌고요 :)

scala> class Complex(str1: String, imaginary: Double) {
     | def st() = str1
     | def im() = imaginary
     | }
defined class Complex

scala> object ComplexNumbers {
     | def main(args: Array[String]) {
     | val c = new Complex("firstData", 3.4)
     | println("String part: " + c.st())
     | println("imaginary part: " + c.im())
     | }
     | }
defined module ComplexNumbers

scala> ComplexNumbers.main(null)
String part: firstData
imaginary part: 3.4

이런 결과가 나오게 됩니다 :) 이해는 바로 되셨을꺼라 생각되네요 :)

그리고 다음으로는 abstract 이건 뭐 :) 설명 없으셔도 알 듯 이전에 자바 하셨던 분이라면

abstract class Term

case class Var(name: String) extends Term

case class Fun(arg: String, body: Term) extends Term

case class App(f: Term, v: Term) extends Term

이런 식으로 사용하시면 됩니다 :) 그리고 이걸 어디에 이용하느냐 바로 case classes :)에 사용하려 합니다.
소스 쭉 나갑니다 메모 메모! :)
scala> val x = Var("x")
x: Var = Var(x)
scala> Console.println(x.name)
x
scala> val x1 = Var("x")
x1: Var = Var(x)
scala> val x2 = Var("x")
x2: Var = Var(x)
scala> val y1 = Var("y")
y1: Var = Var(y)
scala> println("" + x1 + " == " + x2 + " => " + (x1 == x2))
Var(x) == Var(x) => true
scala> println("" + x1 + " == " + y1 + " => " + (x1 == y1))
Var(x) == Var(y) => false

이런식으로 결과 값이 나오게 됩니다. 재미있지 않나요? 특히 저는 x.name 이 부분에 감동을 :)
이걸 응용해서 하나 더 짜보면,
scala> object TermTest extends Application {
     |   def printTerm(term: Term) {
     |     term match {
     |       case Var(n) =>
     |         print(n)
     |       case Fun(x, b) =>
     |         print("^" + x + ".")
     |         printTerm(b)
     |       case App(f, v) =>
     |         Console.print("(")
     |         printTerm(f)
     |         print(" ")
     |         printTerm(v)
     |         print(")")
     |     }
     |   }
     |   def isIdentityFun(term: Term): Boolean = term match {
     |     case Fun(x, Var(y)) if x == y => true
     |     case _ => false
     |   }
     |   val id = Fun("x", Var("x"))
     |   val t = Fun("x", Fun("y", App(Var("x"), Var("y"))))
     |   printTerm(t)
     |   println
     |   println(isIdentityFun(id))
     |   println(isIdentityFun(t))
     | }
defined module TermTest

scala> TermTest
^x.^y.(x y)
true
false
res14: TermTest.type = TermTest$@4b7b1

아주 꼬리에 꼬리를 무는 모듈입니다. :) 너무 너무 좋네요 :)

자 그럼 마지막으로 case classes의 최종본을 볼까요 :)
scala> abstract class Tree
defined class Tree
scala> case class Sum(l: Tree, r: Tree) extends Tree
defined class Sum
scala> case class Var(n: String) extends Tree
defined class Var
scala> case class Const(v: Int) extends Tree
defined class Const

scala> type Environment = String => Int
defined type alias Environment

scala> def eval(t: Tree, env: Environment): Int = t match {
     | case Sum(l, r) => eval(l, env) + eval(r, env)
     | case Var(n) => env(n)
     | case Const(v) => v
     | }
eval: (Tree,(String) => Int)Int
scala> def derive(t: Tree, v: String): Tree = t match {
     | case Sum(l, r) => Sum(derive(l, v), derive(r, v))
     | case Var(n) if (v == n) => Const(1)
     | case _ => Const(0)
     | }
derive: (Tree,String)Tree
scala> def main(args: Array[String]) {
     | val exp: Tree = Sum(Sum(Var("x"),Var("x")),Sum(Const(7),Var("y")))
     | val env: Environment = { case "x" => 5 case "y" => 7 }
     | println("Expression: " + exp)
     | println("Evaluation with x=5, y=7: " + eval(exp, env))
     | println("Derivative relative to x:\n " + derive(exp, "x"))
     | println("Derivative relative to y:\n " + derive(exp, "y"))
     | }
main: (Array[String])Unit
scala> main(null)
Expression: Sum(Sum(Var(x),Var(x)),Sum(Const(7),Var(y)))
Evaluation with x=5, y=7: 24
Derivative relative to x:
 Sum(Sum(Const(1),Const(1)),Sum(Const(0),Const(0)))
Derivative relative to y:
 Sum(Sum(Const(0),Const(0)),Sum(Const(0),Const(1)))

이 정도가 되겠습니다 :)

일단 글이 길어 졌네요 다음편에는 if, for, foreach, switch 와 같은 뭔가 흐름을 제어하는 것들에 대해서 한번 알아 볼까 합니다. :)

<html>

...

<lift:snippet type="show:myForm" form="POST">

<tr><td>Name</td><td><f:name><input type="text"/></f:name></td></tr>

<tr><td>Birthyear</td><td><f:year><select><option>2007</option><option>2006</option></select></f:year></td></tr>

<tr><td>&nbsp;</td><td><input type="submit" value="Add"/></td></tr>

</lift:snippet>

...

</html>

class Show {

   def myForm(xhtml: Group) = {

     var name = ""

     def handleYear(year: String) {

       ... the form's been submitted... do something

     }

     Helpers.bind("f", xhtml, "name" -> SHtml.text(name, name = _),

                   "year" -> SHtml.select((1900 to 2007).toList.reverse.map(v => (v.toString, v.toString)), 

                                       Empty, handleYear _))

   }

}

이렇게 하면 show:myForm 라는 타이프가 scala에 코드와 미묘하게 바인딩이 되는게 보이실 겁니다.


두번째 예제를 보면

<table>

<lift:snippet type="show:users">

<tr><td><f:first_name>David</f:first_name></ 

td><td><f:last_name>Pollak</f:last_name></td></tr>

</lift:snippet>


</table>


그럼 snippet은?


class Show {

   def users(xhtml: Group) = Users.findAll.flatMap(user => bind("f", 

             xhtml, "first_name" --> user.firstName, "last_name" --> user.nameName))

}




정도가 되겠네요. 


자 그럼 다음으로 git으로 공개 되 있는 소스좀 받아 볼까 하는데요.


http://git-scm.com/download 로 가서 다운로드를 시도해 봅시다 


잘 되네요.


자 그럼 

git clone git://github.com/tjweir/pocketchangeapp.git


이 명령어로 소스를 받아 볼까요. 그럼 일단 기본적인 모양이 나오니 참고하시면 좋겠네요.


이제 부터 이 소스를 중점으로 가지고 설명할 것이니.. 꼭 받으세요. 추가로 저는 맥으로 작업 중입니다.

다른 환경에서의 테스트는 해보지 않았기 때문에.. 잘 될지는 모르지만, 지금 모양으로 봐서는 잘 될거 같네요.


다음 화에서는 전체 시스템에 축이 되는 모델에 정의 방법에 대해서 같이 한번 봅시다.

일단 기본 설정 까지는 이렇게 하고 기본적인 구조를 봐 볼까요.

/src/main/webapp 여기에는 HTML소스라던지가 위치하면 되겠네요.. 실제 현재 보고 있는 메인인 index.html이 여기에 있습니다.
그리고 이 폴더에서 한칸 위에 있는
/src/main/webapp/WEB-INF 여길 가 보시면 예전 톰캣 하신분은 아시겠지마, 웹 어플리케이션 설정에 관련된 XML이 들어가 있습니다. 필터 맵핑이라던지, 맵핑이라더지, 해서 url패턴에 따라 접속이 가능하게 한다던지 등등..이 있겠지요.

일단 리프트에서 보게 되는 전체적 구조가 있는데
<prefix:element> 이런식으로 구조를 띄고 있습니다. 이 말은 <lift:surround> 이런식으로 되어 있다는 이야기입니다. 자세한건 조금씩 하면서 보죠.

일단 기본적으로 선언하겠다 싶은게
 <lift:surround with="default" at="content"> 라고 하며 되겠네요. 여기서 디폴트와 그리고 content라는 부분을 잘 봐두세요.
이 부분이 index.html가 있는 폴더에 templates-hidden 폴더로 들어가면
default.html라는 파일이 있는데 여기서 <lift:bind name="content" /> 이 부분에 content입니다.
그리고 혹시 눈치 채신분도 있으시겠지만 파일 이름이 default.html이죠? 아까 그 선언에서 with에 해당하는 이름입니다. 참 특이한 구조군요.

그리고 index.html에 보면 <lift:helloWorld.howdy />  가 있는데 이게 뭔지 좀 봅시다.
일단 이 의미는 helloWorld.scala파일에 howdy라는 펑션이 있을꺼라는 추정이 되네요.
실제로도 그렇고요 src/main/scala/demo/helloworld/snippet 를 보면 HelloWorld.scala라는 파일이 있습니다.
그리고 그 안에 보면 def howdy라는 정의가 있습니다. 뭔가 제대로 가고 있는 것 같네요.

그리고 그 내용을 보면 대충
class HelloWorld {
  def howdy(in: NodeSeq): NodeSeq =
     Helpers.bind("b", in, "time" -> (new _root_.java.util.Date).toString)
}

이런 내용이 써 있는데.. 이 내용을 이야기 하자면, index.html에서
      <lift:helloWorld.howdy>
        <span>Welcome to helloworld at <b:time/></span>
      </lift:helloWorld.howdy>
이 부분이 있는데 이 부분에서 b:time이 부분을 유심히 보면 위에 선언되어 있는 이름이랑 뭔가 딱 들어맞지 않나요? 저도 필이 막 오더라고요.

그리고 이 필은 딱 들어 맞고요. 그걸 나타내는 거 였습니다.

자 다음 화에서는 pocket Change에 대해서 알아 볼까요?

Scala공부를 시작할까 합니다. ^^

오랜만에 시작하는 프로그래밍 언어군요.

일단 이 프로그램 언어는 펑션 프로그래밍이라고 하여 재미있는 점이 꽤 있더라고요.

Getting Started with Scala

자 시작해 봅시다.

일단 왜 스칼라인가 부터 있어야 하지 않을까요? 저도 한지는 얼마 되지 않아서 확실하게 정의하기는 힘들지만.. 일단 이 스칼라라는 언어는 자바를 완벽 지원합니다. 현재 저 같은 경우는 jre1.6.20 에서 작업하는데 완벽 지원되네요 ^^

그리고 또한 그 후에 파생되는 lift라는 프레임워크로 Ruby on Rails(이하 ROR)와 같은 효과를 낼 수 있는 일명 -- 뽑아내기 프로그램이 가능합니다. 그런데 왜! ROR로 하지 스칼라를 먼저 선택해서 해 보는가입니다. 일단.. 현 회사에서 ROR로 만들어져 있고 정말 간단하게 구축되어지는 모습을 보면 ROR을 먼저 파볼까 하고 했지만.. 역시나 속도의 면이나 기동의 면을 봤을 때 스칼라가 더 좋을 거 같더라고요. 일단 펑션 프로그래밍이라는 부분이 있던데 여기에 흥미가 생기더군요. 또한 예전부터 자바 프로그래밍을 했었기 때문에 여러 이슈들에 대해서에 대한 자신감? 하지만 역시 처음 배우는 부분에서는 헤매는건 마찬가지겠지요 :)
하지만.. 헤매는게 어느 정도 시간이 걸리는거는 배워 나가다 보니까 조금씩 익숙해 지는 시간이 줄어 드는 것 같습니다. ^^; 자 그럼 시작해 봅시다.
역시나 제대로된 장점 제대로된 결론적인 것들은 맨 나중에 씁시다. 꼭 목차에 뭐가 좋다 뭐가 좋다 이런거 인터넷에 많이 떠들어져 있지만, 역시 제가 한번 경험해 볼렵니다. 자 고고!

일단 처음 시작이니까 환경 잡아야죠?

일단 윈도우 환경으로 해 볼까요?

1. http://www.scala-lang.org/downloads
여기서 스칼라를 받습니다.
그리고 이게 자바 환경에서 돌아 가기 때문에

2. http://java.sun.com/javase/downloads/widget/jdk6.jsp
자바를 받습니다. ^^

그리고
윈도우 환경 변수를 잡아야 겠죠? 저는 jdk와 scala를 program_lang에다가 깔았어요.

SCALA_HOME : C:\program_lang\scala-2.8.0.RC3
JAVA_HOME : C:\program_lang\Java\jre6
Path : ;%SCALA_HOME%\bin <-이 부분 추가

환경은 이게 끝입니다. ^^;


자 그럼 시작해 볼까요? 역시나 Hello world의 아류작인 Hello Scala!를 만들어 보겠습니다.

window용 CMD
-- Start

C:> scala

 Welcome to Scala ----


  scala> object HelloWorld {

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

       |     println("Hello, world!")

       |   }

       | }

  defined module HelloWorld


  scala> HelloWorld.main(null)

  Hello, world!

  unnamed0: Unit = ()

  scala>:q

--end


이게 다음으로 재미있는게 리눅스나 유닉스에서 쉘 스크립트 프로그래밍으로 쓸 수도 있답니다. ^^

-- 쉘 스크립트 bash start

#!/bin/sh

  exec scala "$0" "$@"

  !#

  object HelloWorld {

    def main(args: Array[String]) {

      println("Hello, world! " + args.toList)

    }

  }

  HelloWorld.main(args)

-- end

자 다음은 scala파일의 컴파일 방법 인데요.

scalac HelloWorld.scala

scalac -d classes HelloWorld.scala <-기본 디렉토리 설정시


실행시

scala HelloWorld

scala -classpath classes HelloWorld <-classes폴더도 포함 실행


만약 기본적 메인을 쓰고 뭔가 간단한 작업만을 하고 싶다면,


object helloAppli extends Application {

  println("Hello, world!")

}

이걸 써도 괜찮네요. Application이라는 클래스를 상속하면 되네요 ^^

그럼 다음 편에서 뵐께요 다음편에서는 스칼라의 주요 기능들이라는 제목으로 할까 생각 중인데.. ^^
주요 기능이라기는 뭐한가? ^^