Scala , 미지와의 조우 작성자 | 이동욱 소속 | SK Planet, Platform SW 개발팀
Scala,����������� ������������������ 미지와의����������� ������������������ 조우
작성자����������� ������������������ ����������� ������������������ |����������� ������������������ ����������� ������������������ 이동욱
소속����������� ������������������ ����������� ������������������ |����������� ������������������ ����������� ������������������ SK����������� ������������������ ����������� ������������������ Planet,����������� ������������������ Platform����������� ������������������ SW����������� ������������������ 개발팀
1.����������� ������������������ Scala����������� ������������������ [맛보기]
2.����������� ������������������ 함수형����������� ������������������ 프로그래밍과����������� ������������������ 객체지향의����������� ������������������ 조우
3.����������� ������������������ 패턴����������� ������������������ 매칭과����������� ������������������ 조우
CONTENTS����������� ������������������ of����������� ������������������ [Scala,����������� ������������������ 미지와의����������� ������������������ 조우]
4.����������� ������������������ 정리의����������� ������������������ 시간
0.����������� ������������������ 들어가며
미지와의����������� ������������������ 조우?Close����������� ������������������ Encounters����������� ������������������ of����������� ������������������ the����������� ������������������ Third����������� ������������������ Kind
미지와의����������� ������������������ 조우라����������� ������������������ 했더니...
발표����������� ������������������ 제목����������� ������������������ 하나����������� ������������������
이상하게����������� ������������������ 지었다가...
40분...대체����������� ������������������ 뭘����������� ������������������ 할����������� ������������������ 수����������� ������������������ 있을까?
- 눈 깜빡이는 사진- 주사기 사진- 라인 스티커 이미지 활용?
- 설마 NHN DeView인데...
주입식으로����������� ������������������ 결정우리는����������� ������������������ 모두����������� ������������������ 주입식����������� ������������������ 교육에����������� ������������������ 친숙하니까...
Scala의����������� ������������������ 기본적인����������� ������������������ 문법을����������� ������������������ 주입식으로����������� ������������������ 익히고����������� ������������������
Java에서����������� ������������������ 지원하지����������� ������������������ 않았던����������� ������������������ 몇가지����������� ������������������ 기능을����������� ������������������ 감상
익히기!
1.����������� ������������������ Scala����������� ������������������ [맛보기]
Scala����������� ������������������ [skah-lah]����������� ������������������ ����������� ������������������ =����������� ������������������ scalable����������� ������������������ language
The����������� ������������������ language����������� ������������������ is����������� ������������������ so����������� ������������������ named����������� ������������������ because����������� ������������������ it����������� ������������������ was����������� ������������������ designed����������� ������������������ to����������� ������������������ grow����������� ������������������ with����������� ������������������ the����������� ������������������ demands����������� ������������������ of����������� ������������������ its����������� ������������������ users.
-����������� ������������������ Programming����������� ������������������ In����������� ������������������ Scala,����������� ������������������ p39����������� ������������������
Scala?
Java와����������� ������������������ 비교해����������� ������������������ 본����������� ������������������ Scala의����������� ������������������ 성능
[참고] http://fupeg.blogspot.com/2008/06/scala-vs-java-performance.html http://fupeg.blogspot.com/2008/06/base-meeting.html
상관계수����������� ������������������ ����������� ������������������ 0.99
Google����������� ������������������ Trend로����������� ������������������ 본����������� ������������������ Scala,����������� ������������������ Groovy,����������� ������������������ Clojure
indeed.com로����������� ������������������ 본����������� ������������������ Scala,����������� ������������������ Groovy,����������� ������������������ Clojure
Java
Scala
Eiffel ML
HaskellEarlang
Smalltalk
Scala는����������� ������������������ 하이브리드����������� ������������������ 언어랍니다
Scala를����������� ������������������ 이용해여러����������� ������������������ 언어들이����������� ������������������ 제공하는����������� ������������������ 특징을����������� ������������������ 접할����������� ������������������ 수����������� ������������������ 있습니다
멀리서����������� ������������������ 본����������� ������������������ Scala
강화된����������� ������������������ 타입����������� ������������������ 시스템
객체����������� ������������������ 지향함수형프로그래밍(hybrid)
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ Scala
Java����������� ������������������ Platform����������� ������������������ /����������� ������������������ .NET����������� ������������������
REPLRead-eval-print����������� ������������������ Loop
scala>����������� ������������������ 1+2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ .
Scala����������� ������������������ REPL에서����������� ������������������ 계산하기
scala>����������� ������������������ 1+2����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ .
메서드 인자
1����������� ������������������ .����������� ������������������ +����������� ������������������ (2)
모든����������� ������������������ 것이����������� ������������������ 객체
객체
public����������� ������������������ class����������� ������������������ Foo()����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ private����������� ������������������ Bar����������� ������������������ bar;
����������� ������������������ ����������� ������������������ ����������� ������������������ public����������� ������������������ Foo(Bar����������� ������������������ bar)����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ this.bar����������� ������������������ =����������� ������������������ bar;����������� ������������������ ����������� ������������������ ����������� ������������������ }
����������� ������������������ ����������� ������������������ ����������� ������������������ public����������� ������������������ Bar����������� ������������������ getBar()����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ return����������� ������������������ bar;����������� ������������������ ����������� ������������������ ����������� ������������������ }
����������� ������������������ ����������� ������������������ ����������� ������������������ public����������� ������������������ void����������� ������������������ setBar(Bar����������� ������������������ bar)����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ this.bar����������� ������������������ =����������� ������������������ bar;����������� ������������������ ����������� ������������������ ����������� ������������������ }}
ScalaJava
클래스����������� ������������������ 선언����������� ������������������ 비교����������� ������������������ (극적인����������� ������������������ 예시)
class����������� ������������������ Foo(var����������� ������������������ bar:Bar)
위치 이동 고려1. 클래스 선언 뒤2. 함수형 코드 읽기 뒤(o)
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ [경고]����������� ������������������ 코드����������� ������������������ 여러����������� ������������������ 번����������� ������������������ 등장정신줄����������� ������������������ 꽉����������� ������������������ 붙잡으셔야����������� ������������������ 합니다.
엄청난����������� ������������������ 속도로����������� ������������������ Scala����������� ������������������ 기초����������� ������������������ 배우기
시작이����������� ������������������ 반이다
변수,����������� ������������������ 그리고����������� ������������������ 타입����������� ������������������ 추론
scala>����������� ������������������ val����������� ������������������ msg����������� ������������������ =����������� ������������������ "Hello,����������� ������������������ DEVIEW����������� ������������������ 2012"
msg:����������� ������������������ java.lang.String����������� ������������������ =����������� ������������������ Hello
scala>����������� ������������������ val����������� ������������������ msg:String����������� ������������������ =����������� ������������������ "Hello,����������� ������������������ DEVIEW����������� ������������������ 2012"
val����������� ������������������ 혹은����������� ������������������ var로����������� ������������������ 변수����������� ������������������ 선언하기����������� ������������������
error:����������� ������������������ reassignment����������� ������������������ to����������� ������������������ val����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ //����������� ������������������ ERRORmsg����������� ������������������ =����������� ������������������ "Goodbye����������� ������������������ world!"
java.lang.String����������� ������������������ =����������� ������������������ Leave����������� ������������������ me����������� ������������������ alone,����������� ������������������ world!����������� ������������������ ����������� ������������������ //OK
val����������� ������������������ msg����������� ������������������ =����������� ������������������ "Hello,����������� ������������������ DEVIEW����������� ������������������ 2012"
msg����������� ������������������ =����������� ������������������ "Goodbye����������� ������������������ world!"
var����������� ������������������ greeting����������� ������������������ =����������� ������������������ "Hello,����������� ������������������ World!"����������� ������������������
greeting����������� ������������������ =����������� ������������������ "Leave����������� ������������������ me����������� ������������������ alone,����������� ������������������ World!"
함수����������� ������������������ 선언하기����������� ������������������
def����������� ������������������ max(x:����������� ������������������ Int,����������� ������������������ y:����������� ������������������ Int):����������� ������������������ Int����������� ������������������ =����������� ������������������ {����������� ������������������ ����������� ������������������ if����������� ������������������ (x����������� ������������������ >����������� ������������������ y)����������� ������������������ x����������� ������������������ ����������� ������������������ else����������� ������������������ y}
클래스����������� ������������������ 정의하기
class����������� ������������������ Rational(n:Int,����������� ������������������ d:Int)����������� ������������������ {����������� ������������������ ����������� ������������������ override����������� ������������������ def����������� ������������������ toString()����������� ������������������ =����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ n����������� ������������������ +����������� ������������������ "/"����������� ������������������ +����������� ������������������ d����������� ������������������ ����������� ������������������ }}
scala>����������� ������������������ val����������� ������������������ half����������� ������������������ =����������� ������������������ new����������� ������������������ Rational(1,2)half:����������� ������������������ Rational����������� ������������������ =����������� ������������������ 1/2
scala>����������� ������������������ half.n<console>:8:����������� ������������������ error:����������� ������������������ value����������� ������������������ n����������� ������������������ is����������� ������������������ not����������� ������������������ a����������� ������������������ member����������� ������������������ of����������� ������������������ Rational����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ half.n����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ^
Java에서의����������� ������������������ 생성자에����������� ������������������ 해당
클래스����������� ������������������ 정의하기����������� ������������������ (var)
class����������� ������������������ Rational(var����������� ������������������ n:Int,����������� ������������������ var����������� ������������������ d:Int)����������� ������������������ {����������� ������������������ ����������� ������������������ override����������� ������������������ def����������� ������������������ toString()����������� ������������������ =����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ n����������� ������������������ +����������� ������������������ "/"����������� ������������������ +����������� ������������������ d����������� ������������������ ����������� ������������������ }}
scala>����������� ������������������ val����������� ������������������ half����������� ������������������ =����������� ������������������ new����������� ������������������ Rational(1,2)half:����������� ������������������ Rational����������� ������������������ =����������� ������������������ 1/2
scala>����������� ������������������ half.dres14:����������� ������������������ Int����������� ������������������ =����������� ������������������ 2
scala>����������� ������������������ half.d����������� ������������������ =����������� ������������������ 4half.d:����������� ������������������ Int����������� ������������������ =����������� ������������������ 4
var����������� ������������������ 가����������� ������������������ 아니라����������� ������������������ ����������� ������������������ ����������� ������������������ val����������� ������������������ 이라면?
class����������� ������������������ Rational(val����������� ������������������ n:Int,����������� ������������������ val����������� ������������������ d:Int)����������� ������������������ {����������� ������������������ ����������� ������������������ override����������� ������������������ def����������� ������������������ toString()����������� ������������������ =����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ n����������� ������������������ +����������� ������������������ "/"����������� ������������������ +����������� ������������������ d����������� ������������������ ����������� ������������������ }}
scala>����������� ������������������ val����������� ������������������ half����������� ������������������ =����������� ������������������ new����������� ������������������ Rational(1,2)half:����������� ������������������ Rational����������� ������������������ =����������� ������������������ 1/2
scala>����������� ������������������ half.d����������� ������������������ =����������� ������������������ 4
<console>:9:����������� ������������������ error:����������� ������������������ reassignment����������� ������������������ to����������� ������������������ val����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ half.d����������� ������������������ =����������� ������������������ 4����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ^
클래스����������� ������������������ 정의하기����������� ������������������ (val)
중급편����������� ������������������ 들어가기
주마간산����������� ������������������ =����������� ������������������ 달리는����������� ������������������ 말에서����������� ������������������ 산을����������� ������������������ 보듯
object����������� ������������������ 정의하기
class����������� ������������������ Person(val����������� ������������������ name:String,����������� ������������������ val����������� ������������������ age:Int)����������� ������������������
object����������� ������������������ Person����������� ������������������ {����������� ������������������ ����������� ������������������ def����������� ������������������ apply(name:String,����������� ������������������ age:Int):Person����������� ������������������ =����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ new����������� ������������������ Person(name,����������� ������������������ age)����������� ������������������ ����������� ������������������ }}
scala>����������� ������������������ Person.apply("아웃사이더",����������� ������������������ 37)res4:����������� ������������������ Person����������� ������������������ =����������� ������������������ Person@fc1c6db
scala>����������� ������������������ Person("네피림",����������� ������������������ 30)res5:����������� ������������������ Person����������� ������������������ =����������� ������������������ Person@67ff67cb
튜플����������� ������������������ (Tuple)
다른����������� ������������������ 타입의����������� ������������������ 자료를����������� ������������������ 담을����������� ������������������ 수����������� ������������������ 있는����������� ������������������ container����������� ������������������ object
scala>����������� ������������������ val����������� ������������������ scarlet����������� ������������������ =����������� ������������������ ("스칼렛",����������� ������������������ 27,����������� ������������������ "서울����������� ������������������ 용산구")
scarlet:����������� ������������������ (java.lang.String,����������� ������������������ Int,����������� ������������������ java.lang.String)����������� ������������������ =����������� ������������������ (스칼렛,27,서울����������� ������������������ 용산구)
scala>����������� ������������������ scarlet._1
res0:����������� ������������������ java.lang.String����������� ������������������ =����������� ������������������ 스칼렛
튜플����������� ������������������ 패턴을����������� ������������������ 이용한����������� ������������������ 대입
각����������� ������������������ 자료형에����������� ������������������ 맞는����������� ������������������ 패턴이����������� ������������������ 있어����������� ������������������ 대입/반복문����������� ������������������ 등에����������� ������������������ 활용할����������� ������������������ 수����������� ������������������ 있다
scala>����������� ������������������ val����������� ������������������ scarlet����������� ������������������ =����������� ������������������ ("스칼렛",����������� ������������������ 27,����������� ������������������ "서울����������� ������������������ 용산구")scala>����������� ������������������ val����������� ������������������ (name,����������� ������������������ age,����������� ������������������ address)����������� ������������������ =����������� ������������������ scarlet
name:����������� ������������������ java.lang.String����������� ������������������ =����������� ������������������ 스칼렛age:����������� ������������������ Int����������� ������������������ =����������� ������������������ 27address:����������� ������������������ java.lang.String����������� ������������������ =����������� ������������������ 서울����������� ������������������ 용산구
List
Scala의����������� ������������������ 기본적����������� ������������������ 컬렉션����������� ������������������ 클래스
scala>����������� ������������������ val����������� ������������������ list����������� ������������������ =����������� ������������������ List(1,2,3)list:����������� ������������������ List[Int]����������� ������������������ =����������� ������������������ List(1,����������� ������������������ 2,����������� ������������������ 3)
List����������� ������������������ Literal
=����������� ������������������ List.apply(1,����������� ������������������ 2,����������� ������������������ 3)����������� ������������������
List����������� ������������������ 패턴을����������� ������������������ 이용한����������� ������������������ 대입
List����������� ������������������ 또한����������� ������������������ 패턴으로����������� ������������������ 존재하므로����������� ������������������ 대입/반복문����������� ������������������ 등에����������� ������������������ 활용할����������� ������������������ 수����������� ������������������ 있다
scala>����������� ������������������ val����������� ������������������ num����������� ������������������ =����������� ������������������ List(1,����������� ������������������ 2,����������� ������������������ 3)
num:����������� ������������������ List[Int]����������� ������������������ =����������� ������������������ List(1,����������� ������������������ 2,����������� ������������������ 3)
scala>����������� ������������������ val����������� ������������������ List(one,two,three)����������� ������������������ =����������� ������������������ num
one:����������� ������������������ Int����������� ������������������ =����������� ������������������ 1two:����������� ������������������ Int����������� ������������������ =����������� ������������������ 2three:����������� ������������������ Int����������� ������������������ =����������� ������������������ 3
Map
Key-Value로����������� ������������������ 이뤄진����������� ������������������ 튜플을����������� ������������������ 구성요소로����������� ������������������ 하는����������� ������������������ 컬렉션����������� ������������������ 클래스단,����������� ������������������ (“A”,����������� ������������������ 10)은����������� ������������������ “A”����������� ������������������ ->����������� ������������������ 10으로도����������� ������������������ 표현할����������� ������������������ 수����������� ������������������ 있다
scala>����������� ������������������ 1����������� ������������������ ->����������� ������������������ "하나"res9:����������� ������������������ (Int,����������� ������������������ java.lang.String)����������� ������������������ =����������� ������������������ (1,하나)
scala>����������� ������������������ val����������� ������������������ hangulNum����������� ������������������ =����������� ������������������ Map(1����������� ������������������ ->����������� ������������������ "하나",����������� ������������������ 2����������� ������������������ ->����������� ������������������ "둘")//����������� ������������������ 결국����������� ������������������ Map((1,"하나"),(2,"둘"))과����������� ������������������ 같다
scala>����������� ������������������ hangulNum(2)res10:����������� ������������������ java.lang.String����������� ������������������ =����������� ������������������ 둘
Option
존재할����������� ������������������ 수도/안����������� ������������������ 할����������� ������������������ 수도����������� ������������������ 있는����������� ������������������ 선택적인����������� ������������������ 값을����������� ������������������ 나타낼����������� ������������������ 때����������� ������������������ 사용.Some의����������� ������������������ 경우����������� ������������������ Some(10)과����������� ������������������ 같이����������� ������������������ 값을����������� ������������������ 함께����������� ������������������ 표기한다.
Option[T]
Some[T] None
Option����������� ������������������ -����������� ������������������ Map에����������� ������������������ 적용된����������� ������������������ Option
scala>����������� ������������������ val����������� ������������������ capitals����������� ������������������ =����������� ������������������ Map("Korea"->"Seoul",����������� ������������������ "Japan"����������� ������������������ ->����������� ������������������ "Tokyo")
scala>����������� ������������������ capitals("Japan")res3:����������� ������������������ java.lang.String����������� ������������������ =����������� ������������������ Tokyo
scala>����������� ������������������ capitals("Russia")java.util.NoSuchElementException:����������� ������������������ key����������� ������������������ not����������� ������������������ found:����������� ������������������ Russia...
scala>����������� ������������������ capitals.get("Russia")res5:����������� ������������������ Option[java.lang.String]����������� ������������������ =����������� ������������������ None
scala>����������� ������������������ capitals.get("Korea")res6:����������� ������������������ Option[java.lang.String]����������� ������������������ =����������� ������������������ Some(Seoul)
Scala����������� ������������������ 중급����������� ������������������ 수료!!
(...응?)
����������� ������������������ 언어는����������� ������������������ 어떻게����������� ������������������ 발전하고����������� ������������������ 있는가?
• 빌딩����������� ������������������ 블록의����������� ������������������ 수가����������� ������������������ 증가하면����������� ������������������ ����������� ������������������ 추상화����������� ������������������ • 언어의����������� ������������������ 지원/라이브러리/프레임워크
프로그래밍����������� ������������������ 언어가����������� ������������������ 추구하는����������� ������������������ 이상
문제����������� ������������������ 영역의����������� ������������������ 크기나����������� ������������������ 복잡도가����������� ������������������ 증가하여도����������� ������������������ 가능하면����������� ������������������ 간단한����������� ������������������ 표현으로����������� ������������������ 문제����������� ������������������ 해결이����������� ������������������ 가능해야����������� ������������������ 함
사용
객체는����������� ������������������ 어떤����������� ������������������ 내용을����������� ������������������ 담는가?
객체에게����������� ������������������ 적절한����������� ������������������ 역할을����������� ������������������ 분배하는����������� ������������������ 쪽에����������� ������������������ 집중되어����������� ������������������ 있음
프로그래밍����������� ������������������ 스타일에����������� ������������������ 따른����������� ������������������ 시간/품질����������� ������������������ 분석
흰����������� ������������������ -����������� ������������������ 구현����������� ������������������ 코드회����������� ������������������ -����������� ������������������ 식별자검����������� ������������������ -����������� ������������������ 타입
흰����������� ������������������ -����������� ������������������ Serviceable회����������� ������������������ -����������� ������������������ Conceptual검����������� ������������������ -����������� ������������������ Failed
코드 읽는 시간 코드 품질
Imperative Style
Functional Style
Imperative Style
Functional Style
[참고] http://infoscience.epfl.ch/record/138586/files/dubochet2009coco.pdf
이번����������� ������������������ Scala����������� ������������������ 세션에서는
추상화����������� ������������������ 수준을����������� ������������������ 높이는����������� ������������������ Java에서는����������� ������������������ 널리����������� ������������������ 활용되지����������� ������������������ 않는����������� ������������������ 함수����������� ������������������ 주고����������� ������������������ 받기와����������� ������������������ 패턴����������� ������������������ 매칭을����������� ������������������ Scala를����������� ������������������ 이용해����������� ������������������ 살펴본다.
함수����������� ������������������ 주고����������� ������������������ 받기
패턴����������� ������������������ 매칭
2.����������� ������������������ 함수형����������� ������������������ 프로그래밍과����������� ������������������ 객체지향의����������� ������������������ 조우
믿음직한����������� ������������������ 함수들����������� ������������������ 이야기Function����������� ������������������ without����������� ������������������ Side����������� ������������������ Effects
imperative����������� ������������������ style
•����������� ������������������ 명령어����������� ������������������ 위주����������� ������������������ -����������� ������������������ if,����������� ������������������ for,����������� ������������������ while����������� ������������������ ...
•����������� ������������������ 부수효과(side-effect)����������� ������������������ -����������� ������������������ 객체의����������� ������������������ 상태를����������� ������������������ 변경함����������� ������������������ -����������� ������������������ var����������� ������������������ 주로����������� ������������������ 사용
(+)����������� ������������������ 기존����������� ������������������ 자바����������� ������������������ 사용자들에게����������� ������������������ 익숙함 (+)����������� ������������������ 이해가����������� ������������������ 쉽고,����������� ������������������ 에러����������� ������������������ 가능성����������� ������������������ 낮춰줌
funtional����������� ������������������ style
•����������� ������������������ 함수����������� ������������������ 위주����������� ������������������ (first-class����������� ������������������ values임)����������� ������������������ -����������� ������������������ 함수����������� ������������������ pass,����������� ������������������ store,����������� ������������������ return����������� ������������������ 가능
•����������� ������������������ 부수����������� ������������������ 효과����������� ������������������ 없음(no����������� ������������������ side-effect)����������� ������������������ -����������� ������������������ referentially����������� ������������������ transparent����������� ������������������ -����������� ������������������ 함수와����������� ������������������ val을����������� ������������������ 주로����������� ������������������ 사용
Scala의����������� ������������������ 위치?����������� ������������������ 함수형과����������� ������������������ 명령형의����������� ������������������ 중간����������� ������������������ 어딘가...
Scala
val����������� ������������������ test����������� ������������������ =����������� ������������������ "abcde"test����������� ������������������ +����������� ������������������ "fg"test.length()����������� ������������������ +����������� ������������������ 5����������� ������������������ //����������� ������������������ 10
•����������� ������������������ 투명참조(Referentially����������� ������������������ Transparent)•����������� ������������������ 수정����������� ������������������ 불가한����������� ������������������ 자료����������� ������������������ 구조(Immutable����������� ������������������ Data����������� ������������������ Structure)����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ "ABC".replace("A","*")����������� ������������������
함수나����������� ������������������ 표현식이����������� ������������������ 결과를����������� ������������������ 만들어내는����������� ������������������ 과정에서����������� ������������������ 상태를����������� ������������������ 변경하지����������� ������������������ 않는����������� ������������������ 것처럼����������� ������������������ 보일����������� ������������������ 경우����������� ������������������ 부수효과(Side����������� ������������������ Effect)가����������� ������������������ 없다고����������� ������������������ 한다.
No����������� ������������������ Side����������� ������������������ Effect?
함수����������� ������������������ 리터럴����������� ������������������ 선언
(x:Int)����������� ������������������ =>����������� ������������������ x����������� ������������������ +����������� ������������������ 1
scala>����������� ������������������ val����������� ������������������ increase����������� ������������������ =����������� ������������������ (x:Int)����������� ������������������ =>����������� ������������������ x����������� ������������������ +����������� ������������������ 1increase:����������� ������������������ Int����������� ������������������ =>����������� ������������������ Int����������� ������������������ =����������� ������������������ <function1>
scala>����������� ������������������ increase(10)res7:����������� ������������������ Int����������� ������������������ =����������� ������������������ 11
함수����������� ������������������ 리터럴을����������� ������������������ 이용해����������� ������������������ 함수를����������� ������������������ 인자로����������� ������������������ 전달하거나,����������� ������������������ 변수에����������� ������������������ 저장,����������� ������������������ 반환할����������� ������������������ 수����������� ������������������ 있다.
Lambda����������� ������������������ 함수
함수도����������� ������������������ 객체다
class����������� ������������������ Increase����������� ������������������ extends����������� ������������������ Function1[Int,Int]����������� ������������������ {����������� ������������������ ����������� ������������������ def����������� ������������������ apply(x:Int):Int����������� ������������������ =����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ x����������� ������������������ +����������� ������������������ 1}
함수가����������� ������������������ 객체라면����������� ������������������ 당연히����������� ������������������ 인자로����������� ������������������ 전달하고,����������� ������������������ 저장하고,����������� ������������������ 결과로����������� ������������������ 반환할����������� ������������������ 수����������� ������������������ 있다
����������� ������������������ ����������� ������������������ val����������� ������������������ increase����������� ������������������ =����������� ������������������ new����������� ������������������ Increase()����������� ������������������ ����������� ������������������ val����������� ������������������ result����������� ������������������ =����������� ������������������ increase(1)����������� ������������������ ����������� ������������������ assert(result����������� ������������������ ===����������� ������������������ 2)
Collection(List)에게����������� ������������������ 함수����������� ������������������ 던져����������� ������������������ 주기
List를����������� ������������������ 처리하는����������� ������������������ 방법:����������� ������������������ 명령형����������� ������������������ vs����������� ������������������ 함수형
5 4 3 2 1
루프를����������� ������������������ 이용한����������� ������������������ List����������� ������������������ 조작
for����������� ������������������ (����������� ������������������ i����������� ������������������ <-����������� ������������������ 0����������� ������������������ to����������� ������������������ 4����������� ������������������ )����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ print(nums(i)����������� ������������������ +����������� ������������������ 1)}
5 4 3 2 1
val����������� ������������������ nums����������� ������������������ =����������� ������������������ List(1,2,3,4,5);
higher-order����������� ������������������ method로����������� ������������������ List����������� ������������������ 조작하기
val����������� ������������������ nums����������� ������������������ =����������� ������������������ List(1,2,3,4,5);
nums.foreach(����������� ������������������ (x)����������� ������������������ =>����������� ������������������ print(x����������� ������������������ +1));nums.foreach(����������� ������������������ (x)����������� ������������������ =>����������� ������������������ println(x����������� ������������������ +1)����������� ������������������ );
5 4 3 2 1
higher-order����������� ������������������ method����������� ������������������ 조작하여����������� ������������������ List����������� ������������������ 조작하기
scala>����������� ������������������ val����������� ������������������ nums����������� ������������������ =����������� ������������������ List(1,2,3,4,5)scala>����������� ������������������ nums.map(����������� ������������������ (x)����������� ������������������ =>����������� ������������������ x+1����������� ������������������ )
res12:����������� ������������������ List[Int]����������� ������������������ =����������� ������������������ List(2,����������� ������������������ 3,����������� ������������������ 4,����������� ������������������ 5,����������� ������������������ 6)
scala>����������� ������������������ nums.filter(����������� ������������������ (x)����������� ������������������ =>����������� ������������������ x����������� ������������������ %����������� ������������������ 2����������� ������������������ ==����������� ������������������ 1����������� ������������������ )
res13:����������� ������������������ List[Int]����������� ������������������ =����������� ������������������ List(1,����������� ������������������ 3,����������� ������������������ 5)
5 4 3 2 1
Javascript로����������� ������������������ 잠시����������� ������������������ 외출����������� ������������������ -����������� ������������������ underscore.js
underscore.js의����������� ������������������ filter,����������� ������������������ map����������� ������������������ -����������� ������������������ Javascript
map_.map(list, iterator, [context]) Alias: collect Produces a new array of values by mapping each value in list through a transformation function (iterator). If the native map method exists, it will be used instead. If list is a JavaScript object, iterator's arguments will be (value, key, list).
_.map([1,����������� ������������������ 2,����������� ������������������ 3],����������� ������������������ function(num){����������� ������������������ return����������� ������������������ num����������� ������������������ *����������� ������������������ 3;����������� ������������������ });
=>����������� ������������������ [3,����������� ������������������ 6,����������� ������������������ 9]
filter_.filter(list, iterator, [context]) Alias: select Looks through each value in the list, returning an array of all the values that pass a truth test (iterator). Delegates to the native filter method, if it exists.
var����������� ������������������ evens����������� ������������������ =����������� ������������������ _.filter([1,����������� ������������������ 2,����������� ������������������ 3,����������� ������������������ 4,����������� ������������������ 5,����������� ������������������ 6],����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ function(num){����������� ������������������ return����������� ������������������ num����������� ������������������ %����������� ������������������ 2����������� ������������������ ==����������� ������������������ 0;����������� ������������������ });
=>����������� ������������������ [2,����������� ������������������ 4,����������� ������������������ 6]
Java와����������� ������������������ Scala����������� ������������������
Java����������� ������������������ 8����������� ������������������ 과����������� ������������������ Scala
JSR-335����������� ������������������ Project����������� ������������������ Lambda
Scala에서����������� ������������������ Java의����������� ������������������ 미래를����������� ������������������ 보다
3.����������� ������������������ 분기,����������� ������������������ 그리고����������� ������������������ 패턴매칭
1/2����������� ������������������ -����������� ������������������ 880p.
Programming����������� ������������������ in����������� ������������������ Scala����������� ������������������
Scala의����������� ������������������ 패턴����������� ������������������ 매칭����������� ������������������ -����������� ������������������ 기본����������� ������������������ 문법
match~case는����������� ������������������ Java의����������� ������������������ switch~case와����������� ������������������ 유사하며����������� ������������������ Scala에서����������� ������������������ 기본으로����������� ������������������ 제공되는����������� ������������������ 패턴도����������� ������������������ 존재한다
num����������� ������������������ match����������� ������������������ {����������� ������������������ ����������� ������������������ case����������� ������������������ 1����������� ������������������ =>����������� ������������������ "정수����������� ������������������ 1"����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ case����������� ������������������ a:Int����������� ������������������ =>����������� ������������������ "1����������� ������������������ 아닌����������� ������������������ 정수����������� ������������������ a"����������� ������������������ ����������� ������������������ case����������� ������������������ _����������� ������������������ =>����������� ������������������ "정수가����������� ������������������ 아닌����������� ������������������ 것"}
Scala의����������� ������������������ 패턴����������� ������������������ 매칭����������� ������������������ 두루보기
List����������� ������������������ 패턴
val����������� ������������������ list����������� ������������������ =����������� ������������������ List(1,2)����������� ������������������ val����������� ������������������ msg����������� ������������������ =����������� ������������������ list����������� ������������������ match����������� ������������������ {
����������� ������������������ ����������� ������������������ case����������� ������������������ List(1,����������� ������������������ _,����������� ������������������ _)����������� ������������������ =>����������� ������������������ "1로����������� ������������������ 시작하는����������� ������������������ 크기����������� ������������������ 3인����������� ������������������ 리스트"����������� ������������������ ����������� ������������������ case����������� ������������������ List(a,����������� ������������������ b)����������� ������������������ =>����������� ������������������ "크기가����������� ������������������ 2인����������� ������������������ 리스트("����������� ������������������ +����������� ������������������ a����������� ������������������ +����������� ������������������ ","����������� ������������������ +����������� ������������������ b����������� ������������������ +����������� ������������������ ")"}����������� ������������������
assert(msg����������� ������������������ ===����������� ������������������ "크기가����������� ������������������ 2인����������� ������������������ 리스트(1,2)")
-����������� ������������������ 변수
-����������� ������������������ 타입����������� ������������������
-����������� ������������������ 와일드����������� ������������������ 카드
-����������� ������������������ 생성자����������� ������������������ 패턴
-����������� ������������������ Sequence����������� ������������������ 패턴(List)
-����������� ������������������ Tuple
-����������� ������������������ 패턴����������� ������������������ 혼합
패턴����������� ������������������ 매칭����������� ������������������ 일반화하기
extractor 객체를����������� ������������������ 분해(decompose)
패턴����������� ������������������ 매칭����������� ������������������ 구상하기����������� ������������������ -����������� ������������������ Twice����������� ������������������
match����������� ������������������ ?
N*2 ����������� ������������������ Twice(����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ )N객체를����������� ������������������ Twice����������� ������������������ 패턴으로����������� ������������������ 분해(decompose)
extractor����������� ������������������ 정의
패턴����������� ������������������ 매
칭����������� ������������������ 수
행
object����������� ������������������ Twice����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ def����������� ������������������ unapply(z:����������� ������������������ Int):����������� ������������������ Option[Int]����������� ������������������ =����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ if����������� ������������������ (z%2����������� ������������������ ==����������� ������������������ 0)����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ Some(z/2)����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ else����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ None}
val����������� ������������������ num����������� ������������������ =����������� ������������������ 32����������� ������������������ *����������� ������������������ 2����������� ������������������ val����������� ������������������ msg����������� ������������������ =����������� ������������������ num����������� ������������������ match����������� ������������������ {����������� ������������������ ����������� ������������������ case����������� ������������������ Twice(a)=>����������� ������������������ a����������� ������������������ +����������� ������������������ "의����������� ������������������ 두����������� ������������������ 배"����������� ������������������ ����������� ������������������ case����������� ������������������ _����������� ������������������ =>����������� ������������������ "정수의����������� ������������������ 두����������� ������������������ 배가����������� ������������������ 아님"}����������� ������������������ assert(msg����������� ������������������ ===����������� ������������������ "32의����������� ������������������ 두����������� ������������������ 배")
extractor:����������� ������������������ 객체를����������� ������������������ 분해해����������� ������������������ 패턴으로����������� ������������������ 표현하기
extractor:����������� ������������������ 패턴����������� ������������������ 매칭의����������� ������������������ 사용자����������� ������������������ 정의����������� ������������������ -����������� ������������������ emailextractor����������� ������������������ 정의
패턴����������� ������������������ 매
칭����������� ������������������ 수
행
object����������� ������������������ Email����������� ������������������ {����������� ������������������ ����������� ������������������ def����������� ������������������ unapply(str:����������� ������������������ String):����������� ������������������ Option[(String,����������� ������������������ String)]����������� ������������������ =����������� ������������������ {����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ val����������� ������������������ elems����������� ������������������ =����������� ������������������ str����������� ������������������ split����������� ������������������ "@"����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ if����������� ������������������ (elems.length����������� ������������������ ==����������� ������������������ 2)����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ Some(elems(0),����������� ������������������ elems(1))����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ else����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ None����������� ������������������ ����������� ������������������ }}
val����������� ������������������ email����������� ������������������ =����������� ������������������ "[email protected]"val����������� ������������������ msg����������� ������������������ =����������� ������������������ email����������� ������������������ match����������� ������������������ {����������� ������������������ ����������� ������������������ case����������� ������������������ Email(����������� ������������������ name,����������� ������������������ "gmail.com"����������� ������������������ )����������� ������������������ =>����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ name����������� ������������������ +����������� ������������������ "����������� ������������������ has����������� ������������������ gmail����������� ������������������ account"����������� ������������������ ����������� ������������������ case����������� ������������������ _����������� ������������������ =>����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ "no����������� ������������������ gmail����������� ������������������ accont"}
4.����������� ������������������ 이제����������� ������������������ 마무리����������� ������������������
Scala����������� ������������������ 학습����������� ������������������ 후기...
*����������� ������������������ 일단����������� ������������������ 학습����������� ������������������ 내용이����������� ������������������ 다양하다.����������� ������������������ 한����������� ������������������ 번����������� ������������������ 봐선����������� ������������������ 잘����������� ������������������ 모른다.
-����������� ������������������ Java는����������� ������������������ 기본
-����������� ������������������ 함수형����������� ������������������ 프로그래밍
-����������� ������������������ 여러����������� ������������������ 언어의����������� ������������������ 특징들을����������� ������������������ 익히게����������� ������������������ 된다
-����������� ������������������ 꼬리����������� ������������������ 재귀,����������� ������������������ 패턴����������� ������������������ 매칭,����������� ������������������ Implicit����������� ������������������ Type����������� ������������������ Conversion
-����������� ������������������ 타입의����������� ������������������ 설계����������� ������������������ 및����������� ������������������ variance����������� ������������������ 관련����������� ������������������ 내용
-����������� ������������������ 동시성����������� ������������������ 관련����������� ������������������ 기법들(Actor,����������� ������������������ STM)
*����������� ������������������ 타입을����������� ������������������ 다루고����������� ������������������ 설계하는����������� ������������������ 일이����������� ������������������ 쉽지만은����������� ������������������ 않음
-����������� ������������������ 특히����������� ������������������ generic����������� ������������������ 관련,����������� ������������������ type����������� ������������������ variance����������� ������������������ 등이����������� ������������������ 들어갈����������� ������������������ 때
-����������� ������������������ Scala가����������� ������������������ 갖고����������� ������������������ 있는����������� ������������������ 문제는����������� ������������������ 아님
-����������� ������������������ 다만����������� ������������������ Scala는����������� ������������������ 정적����������� ������������������ 타입����������� ������������������ 관련����������� ������������������ 더����������� ������������������ 많은����������� ������������������ 설계����������� ������������������ 요소를����������� ������������������ 갖고����������� ������������������ 있다.����������� ������������������
����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ ����������� ������������������ 혼자하긴����������� ������������������ 힘들어요!
발표����������� ������������������ 이후스칼라와����������� ������������������ 어떻게����������� ������������������ 만날����������� ������������������ 수����������� ������������������ 있을까
Programming����������� ������������������ In����������� ������������������ Scala,����������� ������������������ 2nd����������� ������������������ Ed.
9월����������� ������������������ 18일부터����������� ������������������ Martin����������� ������������������ Ordersky의����������� ������������������ 직강����������� ������������������ 시작!����������� ������������������ @Coursera
스칼라 그룹스에서 논의 진행 예정
한국����������� ������������������ Scala����������� ������������������ 사용자����������� ������������������ 모임����������� ������������������ 소개
Programming����������� ������������������ In����������� ������������������ Scala����������� ������������������ 정리도����������� ������������������ 하고����������� ������������������ 있습니다!����������� ������������������
Typesafe