Effective Scala (SpringCamp 2013)

1. Effective Scala Heejong Lee / @heejongl SpringCamp 2013

2. 지금

3. 이곳은... •어떻게

4. 하면

5. Scala를

6. Scala답게

7. 사용

8. 할

9. 수

10. 있는지에

11. 대해

12. 다룹니다 •사소한

13. 테크닉이

14. 아닌

15. Scala

16. 의

17. 바탕에

18. 흐르는

19. 근본적인

20. 철학에

21. 대해

22. 다룹니다 •초급에서

23. 중급

24. 사이의

25. Scala

26. 유저에게

27. 적합합니다 def effectiveScala() { ! println(hello SpringCamp) }

28. 지금

29. 이곳은... •Immutability

31. 함수형

32. 언어의

33. 대표적인

34. 특징으로

35. 일컬어 지는

36. 불변성에

37. 대하여

38. 이야기

39. 합니다 •Composability

41. Scala의

42. 뛰어난

43. 확장성의

44. 근간을

45. 이루는

46. 경로

47. 의존

48. 타입,

49. 함수형

50. 언어와

51. 객체지향형

52. 언어의

53. 패러다 임이

54. 만났을때

55. 생겨나는

56. 특징에

57. 대하여

58. 이야기

59. 합니다 def effectiveScala() { ! println(hello SpringCamp) }

60. 지금

61. 이곳에

62. 계시다면... •Scala의

63. 기본적인

64. 문법을

65. 알고

66. 계셔야

67. 합니다 •객체지향

68. 언어와

69. 그

70. 개념에

71. 대해

72. 익숙해야

73. 합니다 •어느정도의

74. 프로그래밍

75. 경험이

76. 있어야

77. 합니다 def effectiveScala() { ! println(hello SpringCamp) }

78. 지금

79. 이곳에

80. 계시다면... •기본적인

81. 문법

82. 설명은

83. 생략합니다 sealed abstract class Fruit case object Mango extends Fruit case object Apple extends Fruit case object Orange extends Fruit trait FruitDealer { ! def getPrice(f: Fruit) : Double = ! ! f match { ! ! ! case Mango = 3.0 ! ! ! case Apple = 1.1 ! ! ! case Orange = 1.6 ! ! } }

84. Immutability

85. Immutability

86. (不不變性) •한

87. 번

88. 만들어진

89. 객체는

90. 영원히

91. 변하지

92. 않는

93. 것

94. Scala의

95. 불변성 •참조

96. 불변성,

97. 객체

98. 불변성의

99. 두가지

100. 종류가

101. 존재 •var

102. 보다는

103. val

104. 을

105. 사용하도록

106. 권장 •collection.mutable

107. 보다는

108. collection.immutable

109. 을

110. 사용하도록

111. 권장

112. Scala의

113. 불변성 object Immutability extends App { ! val map = Map(Lion - 10.7, Mountain Lion - 10.8) ! map = map + (Mavericks - 10.9) } Immutability.scala:3: error: reassignment to val ! map = map + (Mavericks - 10.9) ^ one error found

114. Scala의

115. 불변성 object Immutability extends App { ! import collection.mutable.Map ! val map = Map(Lion - 10.7, Mountain Lion - 10.8) ! map = map + (Mavericks - 10.9) } Immutability.scala:4: error: reassignment to val ! map = map + (Mavericks - 10.9) ^ one error found

116. Scala의

117. 불변성 object Immutability extends App { ! import collection.mutable.Map ! val map = Map(Lion - 10.7, Mountain Lion - 10.8) ! map += (Mavericks - 10.9) ! println(map(Mavericks)) } 10.9 ?????

118. Scala의

119. 불변성 object Immutability extends App { ! import collection.mutable.Map ! val map = Map(Lion - 10.7, Mountain Lion - 10.8) ! map += (Mavericks - 10.9) ! println(map(Mavericks)) } 10.9 x=x+y

120. 와

121. x.+=(y)는

122. 다릅니다

123. Scala의

124. 불변성 ! ! ! ! ! import collection._ val map = immutable.Map(Lion - 10.7, Mountain Lion - 10.8) var map = immutable.Map(Lion - 10.7, Mountain Lion - 10.8) val map = mutable.Map(Lion - 10.7, Mountain Lion - 10.8) var map = mutable.Map(Lion - 10.7, Mountain Lion - 10.8) 네가지

125. 중

126. 어떤

127. 방법이

128. 옳은

129. 걸까요?

130. Scala의

131. 불변성 ! ! ! ! ! import collection._ val map = immutable.Map(Lion - 10.7, Mountain Lion - 10.8) var map = immutable.Map(Lion - 10.7, Mountain Lion - 10.8) val map = mutable.Map(Lion - 10.7, Mountain Lion - 10.8) var map = mutable.Map(Lion - 10.7, Mountain Lion - 10.8) 객체

132. 불변성이

133. 항상

134. 우선입니다

135. Scala의

136. 불변성 •불변성을

137. 유지하는

138. 것이

139. 왜

140. 필요할까요? •객체에서

141. 상태를

142. 제거하여

143. 디버깅하기

144. 쉽고

145. 병렬화

146. 하기 쉽도록

147. 만듭니다 •참조

148. 투명성

149. (referential

150. transparency)

151. 을

152. 유지하는데

153. 매우

154. 큰

155. 도움이

156. 됩니다.

157. 적어도

158. 객체에

159. 대해서는

160. 부수효과

161. (side-effect)

162. 를

163. 내기

164. 힘드니까요

165. Scala의

167. 투명성

168. (referential

169. transparency) •프로그램의

170. 다른

171. 동작을

172. 바꾸지

173. 않고

174. 어떤

175. 표현식을

176. 그에

177. 해당하는

178. 값으로

179. 치환

180. 할

181. 수

182. 있을때,

183. 그

184. 표현식은

185. 참조

186. 투 명하다고

187. 말합니다 ! ! ! var y = 8 def add2(x: Int) : Int = x + 2 val ten = add2(0) + y ! ! ! var y = 8 def add2(x: Int) : Int = {y += 1; x + 2} val ten = add2(0) + y add2는

188. 참조

189. 투명

190. 합니다 add2는

191. 참조

192. 투명

193. 하지

194. 않습니다

195. Scala의

197. 투명성

198. (referential

199. transparency)

200. 이

201. 가지는

202. 이점 •프로그래머와

203. 컴파일러가

204. 프로그램의

205. 행동에

206. 대해

207. 유추하 기

208. 쉽도록

209. 만듭니다 •따라서,

210. 코드와

211. 알고리즘이

212. 간결해지고

213. 구현이

214. 올바르다 는

215. 사실을

216. 증명하기

217. 쉬워지며 •계산기억하기

218. (memoization),

219. 공통된

220. 표현식

221. 미리

222. 제거 하기

223. (common

224. subexpression

225. elimination),

226. 병렬화

227. (parallelization)

228. 등을

229. 통해

230. 코드를

231. 최적화

232. 할

233. 수

234. 있습니다

235. Scala의

236. 불변성 •불변성

237. 유지의

238. 댓가 •성능에서의

239. 손해를

240. 감수해야

241. 합니다 •반복하기

242. (for,

243. while)

244. 보다

245. 재귀호출,

246. 쌓아가기

247. (fold)

248. 와

249. 친해져야

250. 합니다 •코드가

251. 오히려

252. 더

253. 복잡해지는

254. 경우가

255. 발생합니다

256. Scala의

257. 불변성 •불변성을

258. 유지하는

259. Scala

260. 프로그래밍의

261. 핵심 •case

262. class •foldLeft •@tailrec

263. Scala의

264. 불변성 •case

265. class

266. 란? •함수형

267. 언어의

268. 대수적

269. 데이터

270. 타입

271. (ADT)

272. 에

273. 대응 •객체지향형

274. 언어의

275. 데이터

276. 전달

277. 객체

278. (DTO)

279. 에

280. 대응 •패턴

281. 맞추기를

282. 사용하기

283. 위한

284. 핵심

285. 기작

286. Scala의

287. 불변성 ! ! ! sealed abstract class Tree case class Leaf[A](x: A) extends Tree case class Branch(left: Tree, right: Tree) extends Tree ! ! ! val stringTree = Branch(Branch(Leaf(Fus),Leaf(Ro)),Leaf(Dah)) val intTree = Branch(Branch(Leaf(1),Leaf(2)),Leaf(3)) val hTree = Branch(Branch(Leaf(Fus),Leaf(2)),Leaf(Dah)) Fus Ro stringTree Dah 1 2 intTree 3 Fus 2 hTree Dah

288. Scala의

289. 불변성 def makeUpperCase(tree: Tree) : Tree = tree match { case Branch(left, right) = Branch(makeUpperCase(left),makeUpperCase(right)) case Leaf(x : String) = Leaf(x.toUpperCase) case Leaf(_) = tree } Fus Ro FUS 1 Dah RO stringTree DAH 2 1 Fus 3 2 intTree 3 2 FUS Dah 2 hTree DAH

290. Scala의

292. class

293. 의

294. 갱신 •데이터를

295. 변경하려면

296. 새로운

297. case

298. class를

299. 만들어야

300. 합니 다 •갱신되는

301. 데이터가

302. 많을

303. 경우

304. 동료

305. 객체의

306. apply()

307. 메소드 를

308. 직접

309. 사용 •갱신되는

310. 필드가

311. 적을

312. 경우

313. copy

314. 생성자를

315. 사용

316. Scala의

317. 불변성 ! ! ! case class Person( ! name: String, age: Int, height: Double, weight: Double, ! address: String) ! ! ! val james = Person( ! James, 40, 176.3, 76.9, ! MI6 section, SIS headquarter, London, UK) ! ! ! val jamesNextYear = Person( ! james.name, james.age + 1, james.height, james.weight, ! james.address) ! val jamesLastYear = james.copy(age = james.age - 1)

318. Scala의

320. class

321. 의

322. 특징 •마치

323. 언어에

324. 내장된

325. 데이터

326. 타입처럼

327. 자연스러운 •기본으로

328. 구조적

329. 동일비교 •하지만,

330. 인자가

331. 너무

332. 많거나,

333. 데이터

334. 구조가

335. 너무

336. 깊거나,

337. 어떤

338. 종류라도

339. 상태를

340. 유지

341. 할

342. 필요가

343. 있으면

344. 곤란에

345. 빠질

346. 수

347. 있다

348. Scala의

349. 불변성 ! ! ! ! ! case class Person( ! name: String, age: Int, height: Double, weight: Double, ! numOfCars: Int, numOfBooks: Int, numOfComputers: Int, ! numOfWives: Int, numOfChildren: Int, numOfPhones: Int, ! address: String) ! ! val james = Person( ! James, 40, 176.3, 76.9, 3, 25, 2, ... ?!!

350. Scala의

351. 불변성 ! ! ! ! ! case class Person( ! name: String, age: Int, height: Double, weight: Double, ! numOfCars: Int, numOfBooks: Int, numOfComputers: Int, ! numOfWives: Int, numOfChildren: Int, numOfPhones: Int, ! address: String) ! ! val james = Person( ! James, 40, 176.3, 76.9, 3, 25, 2, ... ?!! ! ! ! ! ! val james = Person( ! name = James, age = 40, height = 176.3, weight ! numOfCars = 3, numOfBooks = 25, numOfComputers = ! numOfWives = 1, numOfChildren = 2, numOfPhones = ! address = MI6 section, SIS headquarter, London, = 76.9, 2, 1, UK)

352. Scala의

353. 불변성 ! ! ! ! case case case case class class class class Person(name: String, age: Int, address: Address) Address(street: String, state: String, country: Country) Country(name: String, location: Location) Location(latitude: Double, longitude: Double) ! ! ! val company = Address(Nuritkum Square,Seoul, ! Country(Republic of Korea, Location(37.34, 126.53))) val person = Person(John, 30, company) ! ! ! ! ! ! ! ! ! ! val personInNewLocation = ! person.copy( ! ! address = person.address.copy( ! ! ! country = person.address.country.copy( ! ! ! ! location = person.address.country.location.copy( ! ! ! ! ! longitude = person.address.country.location.longitude + 1.0 ! ! ! ! ) ! ! ! ) ! ! ) ! )

354. Scala의

355. 불변성 •copy

356. 지옥을

357. 벗어나려면... •특별히

358. 쉬운

359. 방법은

360. 없습니다 •자주

361. 업데이트

362. 되는

363. 필드는

364. 도움

365. 메소드를

366. 만듭니다 •person.addToLongitude(1.0) •shapeless(scrap

367. your

368. boilerplate)

369. /

370. scalaz

371. (lens) •또

372. 다른

373. 지옥문의

374. 시작

375. Scala의

376. 불변성 ! ! ! ! case class Person(firstName: String, lastName: String) { ! val fullName = s$firstName $lastName ! var age = 30 }! ! ! ! val james = Person(James, Bond) james.age = 31 println(james.age)

377. Scala의

378. 불변성 ! ! ! ! case class Person(firstName: String, lastName: String) { ! val fullName = s$firstName $lastName ! var age = 30 }! ! ! ! val james = Person(James, Bond) james.age = 31 println(james.age) ! ! ! ! ! ! case class Person(firstName: String, lastName: String) { ! val fullName = s$firstName $lastName ! private var age = 30 ! def setAge(age: Int) = { this.age = age } ! def getAge = this.age }! ! ! ! val james = Person(James, Bond) james.setAge(31) println(james.getAge)

379. Scala의

380. 불변성 ! ! ! ! case class Person(firstName: String, lastName: String) { ! val fullName = s$firstName $lastName ! var age = 30 }! ! ! val james = Person(James, Bond) james.age = 31 ! ! val anotherJames = Person(James, Bond) anotherJames.age = 60 ! println(james == anotherJames)

381. Scala의

382. 불변성 ! ! ! ! case class Person(firstName: String, lastName: String) { ! val fullName = s$firstName $lastName ! var age = 30 }! ! ! val james = Person(James, Bond) james.age = 31 ! ! val anotherJames = Person(James, Bond) anotherJames.age = 60 ! println(james == anotherJames) true

383. Scala의

384. 불변성 •정리:

385. case

386. class

387. 잘

388. 쓰는

389. 법 •언어에

390. 내장된

391. 상수형

392. 기본

393. 데이터

394. 타입인냥

395. 씁니다

396. (언어 에서

397. 기본적으로

398. 분수를

399. 지원한다면?,

400. 언어에서

401. 기본적으 로

402. 좌표를

403. 지원한다면?) •상태나

404. 상속이

405. 필요하면

406. 그냥

407. class를

408. 씁니다 •case

409. class에

410. 일반

411. class를

412. 넣어

413. 쓰는

414. 것을

415. 피합니다

416. Scala의

417. 불변성 •fold

418. 란? •부수효과가

419. 없는

420. 반복문 •함수형

421. 언어에서

422. 반복연산을

423. 담당 •부수효과가

424. 아닌

425. 값

426. 중심의

427. 연산이기

428. 때문 •모르면

429. 어렵고

430. 알면

431. 쉽습니다

432. Scala의

433. 불변성 ! ! ! val x = List(1,2,3,4,5).foldLeft(0) { ! (sum,num) = sum + num } 0 + 1 = 1 1 + 2 = 3 3 + 3 = 6 6 + 4 = 10 10 + 5 = 15

434. Scala의

435. 불변성 •fold

436. 가

437. 명령형

438. 언어에서의

439. 반복문과

440. 다른점 •일반적인

441. 반복문이

442. 아무것도

443. 되돌려

444. 주지

445. 않는데

446. 반해

447. fold

448. 는

449. 항상

450. 값을

451. 돌려준다 •일반적인

452. 반복문이

453. 연산

454. 중심으로

455. 생각한다면,

456. fold

457. 는

458. 값 이

459. 어떻게

460. 변화하는지를

461. 중심으로

462. 생각한다

463. Scala의

464. 불변성 •컬렉션

465. 안의

466. 값들에

467. 각각

468. 1을

469. 더한다면 ! ! ! ! val col = List(1,2,3,4,5) val result = col.foldRight(List.empty[Int]) { ! (elem,list) = (elem + 1)::list } 결과로

470. 얻어야

471. 하는

472. 것이

473. List이므로,

474. 주어진

475. List

476. 의

477. 원소

478. 각각에

479. 1을

480. 더해 빈

481. 리스트에

482. 쌓아나가자! ! ! ! ! int array[] = {1,2,3,4,5}; for(int i = 0; i array.length; i++) { ! array[i] = array[i] + 1; } Array

483. 각각의

484. 칸에

485. 1을

486. 더하는

487. 작업을,

488. Array의

489. 길이만큼

490. 반복해보자!

491. Scala의

492. 불변성 •정리:

493. fold

494. 잘

495. 쓰는

496. 법 •항상

497. 값

498. 중심으로

499. 먼저

500. 생각하는

501. 습관을

502. 들입니다 •많이

503. 써보는

504. 방법이

505. 제일

506. 입니다 •성능이

507. 중요하거나

508. 부수효과가

509. 꼭

510. 필요할

511. 때는

512. for

513. 대신

514. while

515. 을

516. 씁니다 •Scala

517. 의

518. for

519. 는

520. 명령형

521. 언어에서

522. 흔히

523. 말하는

524. for

525. 와

526. 다 릅니다

527. Scala의

528. 불변성 •꼬리

529. 재귀란? •재귀

530. 호출을

531. 최적화

532. 하기

533. 위해

534. 요구되는

535. 조건 •꼬리

536. 재귀를

537. 이용하면

538. 함수

539. 호출을

540. 단순한

541. 반복문으로

542. 최 적화

543. 할

544. 수

545. 있어

546. 스택

547. 넘침

548. 방지

549. 및

550. 호출

551. 부담을

552. 줄이는데

553. 도움이

554. 된다

555. Scala의

557. 안의

558. 값들에

559. 각각

560. 1을

561. 더한다면 ! ! ! ! ! ! def addOne(list: List[Int]) : List[Int] = { ! list match { ! ! case Nil = Nil ! ! case head::tail = (head + 1)::addOne(tail) ! } } ! ! val col = List(1,2,3,4,5) val result = addOne(col)

562. Scala의

564. 안의

565. 값들에

566. 각각

567. 1을

568. 더한다면 ! ! ! ! ! ! def addOne(list: List[Int]) : List[Int] = { ! list match { ! ! case Nil = Nil ! ! case head::tail = (head + 1)::addOne(tail) ! } } ! ! val col = List(1,2,3,4,5) val result = addOne(col) List(2, 3, 4, 5, 6) 그러나

569. ...

570. Scala의

572. 안의

573. 값들에

574. 각각

575. 1을

576. 더한다면 ! ! ! ! ! ! def addOne(list: List[Int]) : List[Int] = { ! list match { ! ! case Nil = Nil ! ! case head::tail = (head + 1)::addOne(tail) ! } } ! ! val col = (0 to 1000000).toList val result = addOne(col) java.lang.StackOverflowError ! at java.lang.Integer.intValue(Integer.java:701) ! at scala.runtime.BoxesRunTime.unboxToInt(BoxesRunTime.java.. ! at Immutability$.addOne(Immutability.scala:6) ! at Immutability$.addOne(Immutability.scala:6)

577. Scala의

579. 안의

580. 값들에

581. 각각

582. 1을

583. 더한다면 ! ! ! ! ! ! def addOne(list: List[Int]) : List[Int] = { ! list match { ! ! case Nil = Nil ! ! case head::tail = (head + 1)::addOne(tail) ! } } ! ! val col = (0 to 1000000).toList val result = addOne(col) 0

584. 에다

585. 1을

586. 더한

587. 1을

588. addOne(1...1000000)

589. 의

590. 결과에

591. 붙여야해

592. ... 1

593. 에다

594. 1을

595. 더한

596. 2를

597. addOne(2...1000000)

598. 의

599. 결과에

600. 붙여야해

601. ... 2

602. 에다

603. 1을

604. 더한

605. 3를

606. addOne(3...1000000)

607. 의

608. 결과에

609. 붙여야해

610. ... 아직

611. addOne()

612. 들의

613. 결과를

614. 알

615. 수

616. 없으니

617. 1,2,3은

618. 계속

619. 기억하고

620. 있어야겠구나!

621. Scala의

623. 안의

624. 값들에

625. 각각

626. 1을

627. 더한다면 ! ! ! ! ! ! def addOne(list: List[Int], result: List[Int] = List.empty) : List[Int] = { ! list match { ! ! case Nil = result.reverse ! ! case head::tail = addOne(tail, (head + 1)::result) ! } } ! ! val col = (0 to 1000000).toList val result = addOne(col) 아하!

628. 남은

629. 할일을

630. 미리

631. 해서

632. 넘겨주고

633. 잊어버리자

634. Scala의

636. 안의

637. 값들에

638. 각각

639. 1을

640. 더한다면 ! ! ! ! ! ! ! ! import scala.annotation.tailrec @tailrec def addOne(list: List[Int], result: List[Int] = List.empty) : List[Int] = { ! list match { ! ! case Nil = result.reverse ! ! case head::tail = addOne(tail, (head + 1)::result) ! } } 그리고

641. 컴파일러가

642. 한번

643. 더

644. 확인

645. 할

646. 수

647. 있도록

648. 표시하자 @tailrec

649. Scala의

651. 안의

652. 값들에

653. 각각

654. 1을

655. 더한다면 ! ! ! ! ! ! ! ! import scala.annotation.tailrec @tailrec def addOne(list: List[Int]) : List[Int] = { ! list match { ! ! case Nil = Nil ! ! case head::tail = (head + 1)::addOne(tail) ! } } Immutability.scala:5: error: could not optimize @tailrec annotated method addOne: it contains a recursive call not in tail position ! ! list match { ^ one error found

656. Scala의

658. 안의

659. 값들에

660. 각각

661. 1을

662. 더한다면 ! ! ! ! ! ! ! ! import scala.annotation.tailrec @tailrec def addOne(list: List[Int], result: List[Int] = List.empty) : List[Int] = { ! list match { ! ! case Nil = result.reverse ! ! case head::tail = addOne(tail, (head + 1)::result) ! } } 꼬리

663. 재귀는

664. 반복문으로

665. 쉽게

666. 변환

667. 가능하다 ! ! ! col.foldLeft(List.empty[Int]){ ! (result,head) = (head + 1)::result }.reverse

668. Scala의

669. 불변성 •정리:

670. 꼬리

671. 재귀

672. 잘

673. 쓰는

674. 법 •동일한

675. 형태의

676. fold

677. 를

678. 여러번

679. 재사용

680. 해야

681. 할

682. 때

683. 꼬리

684. 재 귀

685. 형태의

686. 함수로

687. 만든다 •기본

688. 인자를

689. 사용하면

690. 도움

691. 함수를

692. 따로

693. 만들지

694. 않아도

695. 되 므로

696. 편하다 •복잡한

697. 함수에는

698. 항상

699. @tailrec

700. 을

701. 붙여

702. 꼬리재귀

703. 임을

704. 컴 파일러에게

705. 확인

706. 받도록

707. 한다

708. Scala의

709. 불변성 •정리:

710. 불변성 •함수를

711. 일반적인

712. 하나의

713. 값으로,

714. 함수형

715. 언어

716. 답게

717. 사용하 고

718. 싶다면

719. 꼭

720. 지켜주셔야

721. 합니다 •강제

722. 사항은

723. 아닙니다.

724. “hello

725. world”

726. 하나

727. 출력하기

728. 위해

729. monad

730. 같은

731. 것을

732. 알

733. 필요는

734. 없습니다

735. :)

736. Composability

737. (構成性) •부분이나

738. 요소들을

739. 모아서

740. 전체를

741. 짜

742. 이루는

743. 것

744. Scala의

745. 구성성 •코드

746. 재사용의

747. 핵심

748. :

749. 정보

750. 숨기기 •서로를

751. 구성하는데

752. 꼭

753. 필요한

754. 정보가

755. 아니면

756. 다른

757. 모듈 에서

758. 볼

759. 수

760. 없도록

761. Scala의

762. 구성성 •우리는

763. 스마트폰이

764. 제공하는

765. 기능들을

766. 사용합니다 •만일

767. 고장나면

768. 제조사로

769. 다시

770. 가져가야

771. 고칠

772. 수

773. 있습니다 •스마트폰을

774. 잘

775. 사용하기

776. 위해

777. 내부를

778. 알

779. 필요는

780. 없습니다

781. Scala의

782. 구성성 •우리는

783. 객체가

784. 제공하는

785. 기능들을

786. 사용합니다 •객체의

787. 관리는

788. 그

789. 객체를

790. 만든

791. 부모

792. 인스턴스가

793. 합니다 •객체를

794. 잘

795. 사용하기

796. 위해

797. 내부를

798. 알

799. 필요는

800. 없습니다

801. Scala의

802. 구성성 •Scala

803. 구성성의

804. 토대

805. :

806. 경로

807. 의존

808. 타입 •클래스

809. 내부에

810. 정의된

811. 타입

812. 멤버의

813. 타입은

814. 항상

815. 그

816. 클래스

817. 객체의

818. 인스턴스에

819. 의존한다

820. Scala의

821. 구성성 ! ! ! ! ! ! case class CellPhoneMaker(name: String) { ! abstract class Model ! case object SmartPhone3 extends Model ! case object SmartPhone4 extends Model ! case object SmartPad extends Model } ! ! ! ! val apple = CellPhoneMaker(Apple) val apple2 = CellPhoneMaker(Apple)! println(apple == apple2) println(apple.SuperPhone1 == apple2.SuperPhone1)

822. Scala의

823. 구성성 ! ! ! ! ! ! case class CellPhoneMaker(name: String) { ! abstract class Model ! case object SmartPhone3 extends Model ! case object SmartPhone4 extends Model ! case object SmartPad extends Model } ! ! ! ! val apple = CellPhoneMaker(Apple) val apple2 = CellPhoneMaker(Apple)! println(apple == apple2) println(apple.SuperPhone1 == apple2.SuperPhone1) true false

824. Scala의

825. 구성성 •스마트폰

826. 공장을

827. 만듭시다 ! ! class CellPhoneMaker(name: String, address: String) { ! var uniqueSerial = 0 ! ! ! ! ! ! ! ! sealed abstract class Model case class SmartPhone1(serial: Int, working: Boolean) extends Model case class SmartPhone2(serial: Int, working: Boolean) extends Model case class SmartPad(serial: Int, working: Boolean) extends Model ! ! ! ! ! ! ! ! def produce() : Model = { ! uniqueSerial += 1 ! SmartPhone2(uniqueSerial,true) } ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! } def ! ! ! ! ! } fix(phone: Model) : Model = { phone match { ! case phone : SmartPhone1 = phone.copy(working = true) ! case phone : SmartPhone2 = phone.copy(working = true) ! case pad : SmartPad = pad.copy(working = true) }

828. Scala의

829. 구성성 •스마트폰

830. 공장을

831. 만듭시다 ! ! val apple = new CellPhoneMaker(Apple, Cupertino) val lg = new CellPhoneMaker(LG, Seoul) ! ! val phoneFromApple = apple.produce() val phoneFromLG = lg.produce() ! apple.fix(phoneFromLG) Composability.scala:30: error: type mismatch; found : Composability.lg.Model required: Composability.apple.Model ! apple.fix(phoneFromLG) ^ one error found

832. Scala의

833. 구성성 •내부

834. 객체

835. (내부

836. 클래스,

837. 멤버

838. 타입,

839. 내부

840. 트레잇)

841. 선언은 •선언을

842. 포함하는

843. 타입이

844. 선언되는

845. 타입을

846. 다루는

847. 주체가

848. 됨을

849. 뜻합니다 •경로

850. 의존

851. 타입

852. 시스템을

853. 통해

854. 컴파일러의

855. 타입체커가

856. 내 부

857. 객체

858. 인스턴스의

859. 부모가

860. 누구인지를

861. 실행

862. 전에

863. 안전하 게

864. 검사해

865. 줍니다

866. Scala의

867. 구성성 •서로서로

868. 고쳐주는

869. 스마트폰

870. 공장

871. 조합을

872. 만듭시다 ! ! class CellPhoneMaker(name: String, address: String) { ! var uniqueSerial = 0 ! ! ! ! ! ! ! ! sealed abstract class Model case class SmartPhone1(serial: Int, working: Boolean) extends Model case class SmartPhone2(serial: Int, working: Boolean) extends Model case class SmartPad(serial: Int, working: Boolean) extends Model ! ! ! ! ! ! ! ! def produce() : Model = { ! uniqueSerial += 1 ! SmartPhone2(uniqueSerial,true) } ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! } def ! ! ! ! ! } fix(phone: CellPhoneMaker#Model) : CellPhoneMaker#Model = { phone match { ! case phone : CellPhoneMaker#SmartPhone1 = phone.copy(working = true) ! case phone : CellPhoneMaker#SmartPhone2 = phone.copy(working = true) ! case pad : CellPhoneMaker#SmartPad = pad.copy(working = true) }

873. Scala의

874. 구성성 •서로서로

875. 고쳐주는

876. 스마트폰

877. 공장

878. 조합을

879. 만듭시다 ! ! val apple = new CellPhoneMaker(Apple, Cupertino) val lg = new CellPhoneMaker(LG, Seoul) ! ! val phoneFromApple = apple.produce() val phoneFromLG = lg.produce() ! apple.fix(phoneFromLG) #

880. 을

881. 사용하면

882. 타입

883. 조건을

884. 완화

885. 할

886. 수

887. 있습니다

888. Scala의

890. 구성성의

891. 뼈대

892. :

893. 트레잇

894. (trait) •자유로운

895. 조합이

896. 가능한

897. 구성의

898. 기본

899. 단위 •우선

900. 순위가

901. 있는

902. 다중

903. 상속

904. 지원 •구현을

905. 포함

906. 할

907. 수

908. 있는

909. 인터페이스

910. Scala의

911. 구성성 •공장을

912. 재사용

913. 합시다 ! ! class CellPhoneMaker(name: String, address: String) { ! var uniqueSerial = 0 ! ! ! ! ! ! ! ! sealed abstract class Model case class SmartPhone1(serial: Int, working: Boolean) extends Model case class SmartPhone2(serial: Int, working: Boolean) extends Model case class SmartPad(serial: Int, working: Boolean) extends Model ! ! ! ! ! ! ! ! def produce() : Model = { ! uniqueSerial += 1 ! SmartPhone2(uniqueSerial,true) } ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! } def ! ! ! ! ! } fix(phone: Model) : Model = { phone match { ! case phone : SmartPhone1 = phone.copy(working = true) ! case phone : SmartPhone2 = phone.copy(working = true) ! case pad : SmartPad = pad.copy(working = true) }

914. Scala의

916. 재사용

917. 합시다 ! ! ! ! ! trait Maker { ! val name : String ! val address : String ! ! abstract class Model ! ! ! ! def defaultModel(serial: Int) : Model var uniqueSerial = 0 ! ! ! ! ! ! ! ! def produce() : Model = { ! uniqueSerial += 1 ! defaultModel(uniqueSerial) } ! ! ! } def fix(m: Model) : Model = ???

918. Scala의

920. 재사용

921. 합시다 ! ! ! ! ! trait Maker { ! val name : String ! val address : String ! ! abstract class Model ! ! ! ! def defaultModel(serial: Int) : Model var uniqueSerial = 0 ! ! ! ! ! ! ! ! def produce() : Model = { ! uniqueSerial += 1 ! defaultModel(uniqueSerial) } ! ! ! } def fix(m: Model) : Model = ??? ! ! ! ! class CellPhoneMaker(val name: String, val address: String) extends Maker { ! case class SmartPhone1(serial: Int, working: Boolean) extends Model ! case class SmartPhone2(serial: Int, working: Boolean) extends Model ! case class SmartPad(serial: Int, working: Boolean) extends Model ! ! ! } def defaultModel(serial: Int) = SmartPhone2(serial,true)

922. Scala의

923. 구성성 •자전거

924. 공장은

925. 어떨까요? ! ! ! ! class BikeMaker(val name: String, val address: String) extends Maker { ! case class AluminiumBike1(serial: Int, working: Boolean) extends Model ! case class AluminiumBike2(serial: Int, working: Boolean) extends Model ! case class TitaniumBike(serial: Int, working: Boolean) extends Model ! ! ! } def defaultModel(serial: Int) = TitaniumBike(serial,true) •자동차는요? ! ! ! ! class CarMaker(val name: String, val address: String) extends Maker { ! case class SmallCar(serial: Int, working: Boolean) extends Model ! case class MediumCar(serial: Int, working: Boolean) extends Model ! case class LargeCar(serial: Int, working: Boolean) extends Model ! ! ! } def defaultModel(serial: Int) = MediumCar(serial,true)

926. Scala의

928. 재사용

929. 합시다 ! ! ! ! ! trait Maker { ! val name : String ! val address : String ! ! abstract class Model ! ! ! ! def defaultModel(serial: Int) : Model var uniqueSerial = 0 ! ! ! ! ! ! ! ! def produce() : Model = { ! uniqueSerial += 1 ! defaultModel(uniqueSerial) } ! ! ! } def fix(m: Model) : Model = ??? Model

930. 을

931. 새롭게

932. 만드는

933. 방법이

934. 필요합니다

935. Scala의

937. 재사용

938. 합시다 ! ! ! ! ! ! ! trait Maker { ! val name : String ! val address : String ! ! abstract class Model { ! ! def builder(working: Boolean) : Model ! } ! ! ! ! def defaultModel(serial: Int) : Model var uniqueSerial = 0 ! ! ! ! ! ! ! ! def produce() : Model = { ! uniqueSerial += 1 ! defaultModel(uniqueSerial) } ! ! ! } def fix(m: Model) : Model = m.builder(true)

939. Scala의

941. 재사용

942. 합시다 ! ! ! ! ! ! ! ! ! ! class CellPhoneMaker(val name: String, val address: String) extends Maker { ! case class SmartPhone1(serial: Int, working: Boolean) extends Model { ! ! def builder(working: Boolean) = this.copy(working = working) ! } ! case class SmartPhone2(serial: Int, working: Boolean) extends Model { ! ! def builder(working: Boolean) = this.copy(working = working) ! } ! case class SmartPad(serial: Int, working: Boolean) extends Model { ! ! def builder(working: Boolean) = this.copy(working = working) ! } ! ! ! } def defaultModel(serial: Int) = SmartPhone2(serial,true)

943. Scala의

944. 구성성 •확장성

945. 있는

946. 프로그램

947. 디자인을

948. 위한

949. 팁 •가능하면

950. 추상

951. 클래스

952. 대신

953. 트레잇을

954. 사용합니다 •조금이라도

955. 중복되는

956. 코드가

957. 있으면

958. 트레잇으로

959. 추출하고

960. 섞어

961. 넣어

962. 사용합니다

963. (훌륭한

964. 예:

965. Scala

966. 표준

967. 라이브러리)

968. Scala의

970. 의

971. 강점은

972. 함수형

973. 언어의

974. 특징과

975. 객체

976. 지향형

977. 언어의

978. 특징을

979. 모두

980. 가지고

981. 있다는

982. 것 •함수형

983. 언어는

984. 값

985. 중심의

986. 연산을

987. 강조하고

988. 함수를

989. 기본적 인

990. 타입으로

991. 여기나,

992. 커다란

993. 프로그램을

994. 확장성

995. 있게

996. 구성 하는데

997. 약점이

998. 있다 •객체

999. 지향형

1000. 언어는

1001. 여러가지

1002. 패턴을

1003. 통해

1004. 커다란

1005. 프로그 램을

1006. 확장성

1007. 있게

1008. 구성하는데

1009. 장점이

1010. 있으나,

1011. 함수형

1012. 언어 의

1013. 새롭고

1014. 안전한

1015. 기능들을

1016. 사용하지

1017. 못한다

1018. Scala의

1020. 를

1021. 통해

1022. 함수형

1023. 언어의

1024. 타입추론,

1025. 불변성과

1026. 같은

1027. 훌륭 한

1028. 특징들과

1029. 객체

1030. 지향형

1031. 언어의

1032. 뛰어난

1033. 프로그램

1034. 디자인을

1035. 동 시에

1036. 사용

1037. 할

1038. 수

1039. 있다 •그러나,

1040. 두가지

1041. 패러다임이

1042. 충돌하여

1043. 나타나는

1044. 선택의

1045. 문제 가

1046. 있다

1047. Scala의

1048. 구성성 •함수형

1049. 언어

1050. 스타일 ! ! ! sealed abstract class Value case class IntValue(x: Int) extends Value case class StringValue(x: String) extends Value ! ! ! ! ! ! ! ! ! ! ! ! object Eval { ! def add(e1: Value, e2: Value) : Option[Int] = ! ! (e1,e2) match { ! ! ! case (IntValue(x), IntValue(y)) = Some(x + y) ! ! ! case _ = None ! ! } ! def concat(e1: Value, e2: Value) : Option[String] = ! (e1,e2) match { ! ! case (StringValue(x), StringValue(y)) = Some(x + y) ! ! case _ = None ! } }

1051. Scala의

1052. 구성성 •객체지향

1053. 언어

1054. 스타일 ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! sealed abstract class Value { ! def add(other: Value) : Option[Int] ! def concat(other: Value) : Option[String] } case class IntValue(x: Int) extends Value { ! def add(other: Value) : Option[Int] = ! ! other match { ! ! ! case IntValue(y) = Some(x + y) ! ! ! case _ = None ! ! } ! def concat(other: Value) : Option[String] = ! ! other match { ! ! ! case _ = None ! ! } } case class StringValue(x: String) extends Value { ! def add(other: Value) : Option[Int] = ! ! other match { ! ! ! case _ = None ! ! } ! def concat(other: Value) : Option[String] = ! ! other match { ! ! ! case StringValue(y) = Some(x + y) ! ! ! case _ = None ! ! }! }

1055. Scala의

1056. 구성성 •스타일

1057. 선택의

1058. 딜레마 •데이터

1059. 타입의

1060. 변화가

1061. 빈번하다면

1062. 객체지향

1063. 스타일로 •연산의

1064. 변화가

1065. 빈번하다면

1066. 함수형

1067. 스타일로

1068. 정리 •Scala

1069. 는

1070. 그냥

1071. Java

1072. 처럼

1073. 짜도

1074. 됩니다 •그러나,

1075. Scala

1076. 의

1077. 진정한

1078. 강점은

1079. 멀티

1080. 패러다임에

1081. 있습니다 •함수형

1082. 스타일의

1083. 특징인

1084. 불변성과,

1085. Scala

1086. 만의

1087. 특징인

1088. 구성 성을

1089. 고려하며

1090. 디자인하면

1091. 아름답고

1092. 확장성

1093. 높은

1094. 프로그램을

1095. 만들

1096. 수

1097. 있습니다

1098. 감사합니다

Effective Scala (SpringCamp 2013)

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (6)

Destaque

Destaque (8)

Effective Scala (SpringCamp 2013)