Scala in Action

Scala in Action......Page 1
brief contents......Page 6
contents......Page 8
foreword......Page 14
preface......Page 16
acknowledgments......Page 17
Who should read this book?......Page 18
Part 2: Working with Scala......Page 19
Software requirements......Page 20
Author Online forum......Page 21
about the cover illustration......Page 22
Part 1 Scala: the basics......Page 24
1 Why Scala?......Page 26
1.1.1 Scala as an object-oriented language......Page 27
1.1.2 Scala as a functional language......Page 29
1.1.3 Scala as a multi-paradigm language......Page 31
1.1.4 Scala as a scalable and extensible language......Page 32
1.1.5 Scala runs on the JVM......Page 33
1.2.2 Programming for multicores......Page 34
1.3.2 Scala does more with less code......Page 36
1.4 Coming from a dynamic language......Page 38
1.4.1 Case for static typing, the right way......Page 39
1.6 Summary......Page 41
2 Getting started......Page 43
2.1 REPL with Scala interpreter......Page 44
2.2 Scala basics......Page 45
2.2.1 Basic types......Page 46
2.2.2 Defining variables......Page 51
2.2.3 Defining functions......Page 53
2.3 Working with Array and List......Page 59
2.4 Controlling flow with loops and ifs......Page 61
2.5 For-comprehensions......Page 62
2.6 Pattern matching......Page 65
2.7 Exception handling......Page 68
2.8 Command-line REST client: building a working example......Page 69
2.8.1 Introducing HttpClient library......Page 71
2.8.2 Building the client, step by step......Page 72
2.9 Summary......Page 77
3 OOP in Scala......Page 78
3.1 Building a Scala MongoDB driver: user stories......Page 79
3.2 Classes and constructors......Page 80
3.3 Packaging......Page 84
3.4 Scala imports......Page 86
3.5 Objects and companion objects......Page 88
3.6 Mixin with Scala traits......Page 92
3.6.1 Class linearization......Page 98
3.6.2 Stackable traits......Page 100
3.7 Case class......Page 101
3.8 Named and default arguments and copy constructors......Page 106
3.9 Modifiers......Page 109
3.10 Value classes: objects on a diet......Page 110
3.11 Implicit conversion with implicit classes......Page 111
3.12 Scala class hierarchy......Page 114
3.13 Summary......Page 115
4 functional data structures......Page 116
4.1 Introducing type parameterization......Page 117
4.2 Type variance with covariance and contravariance......Page 118
4.3 Lower and upper type bounds......Page 122
4.4 Higher-order functions, including map, flatMap, and friends......Page 124
4.5 Using foldLeft and foldRight......Page 129
4.6 Building your own function objects......Page 131
4.7 Scala collection hierarchy......Page 133
4.8 Mutable and immutable collections......Page 136
4.9 Working with List and ListBuffer......Page 137
4.9.1 Working with Set and SortedSet......Page 138
4.9.2 Working with Map and Tuple......Page 140
4.9.3 Under the hood of for-comprehension......Page 141
4.9.4 Use Option not Null......Page 144
4.10 Working with lazy collections: views and streams......Page 145
4.10.1 Convert a strict collection to a nonstrict collection with views......Page 146
4.10.2 Working with Streams......Page 148
4.11 Divide and conquer with parallel collections......Page 150
4.11.1 Parallel collection hierarchy......Page 152
4.11.2 Switching between sequential and parallel collections......Page 153
4.12 Summary......Page 154
5 Functional programming......Page 155
5.1 What is functional programming?......Page 156
5.1.1 The benefits of referential transparency......Page 157
5.2 Moving from OOP to functional programming......Page 158
5.2.1 Pure vs. impure programming......Page 159
5.2.2 Object-oriented patterns in functional programming......Page 160
5.2.3 Modeling purely functional programs......Page 161
5.3 Functions in all shapes and forms......Page 163
5.3.2 Higher-order functions......Page 164
5.3.3 Function currying......Page 167
5.3.4 Function composition and partial functions......Page 168
5.3.5 Recursion......Page 171
5.4 Thinking recursively......Page 172
5.4.1 Tail recursion......Page 173
5.5 Algebraic data types......Page 175
5.6 Why does functional programming matter?......Page 176
5.7 Building higher abstractions with monads......Page 179
5.7.1 Managing state using monads......Page 180
5.7.2 Building blocks for monads......Page 186
5.8 Summary......Page 188
Part 2 Working with Scala......Page 190
6 Building web applications in functional style......Page 192
6.1 Building weKanban: a simple web-based Kanban board......Page 193
6.2 Building Scala applications using Simple Build Tool......Page 194
6.2.1 Setting up SBT......Page 195
6.2.2 Understanding the basics of SBT......Page 196
6.2.3 Setting up the weKanban project with SBT......Page 204
6.3.1 How the Scalaz HTTP library works......Page 206
6.3.2 Configuring Scalaz with SBT......Page 210
6.3.3 Building your first web page using Scalaz......Page 212
6.4 Summary......Page 215
7 Connecting to a database......Page 216
7.1.1 Connecting to a database using Squeryl......Page 217
7.1.2 Saving a new story to the database......Page 223
7.1.3 Building the Create Story web page......Page 227
7.2 Building the Kanban board page......Page 235
7.2.1 Creating the view for the Kanban board......Page 237
7.2.2 Moving cards in the Kanban board......Page 241
7.3 Summary......Page 246
8 Building scalable and extensible components......Page 247
8.1 Building your first component in Scala......Page 248
8.1.1 Abstract type members......Page 249
8.1.2 Self type members......Page 251
8.1.3 Building a scalable component......Page 252
8.1.4 Building an extensible component......Page 255
8.2.1 Structural types......Page 261
8.2.2 Higher-kinded types......Page 263
8.2.3 Phantom types......Page 266
8.3.1 Modeling orthogonal concerns using type classes......Page 269
8.3.2 Solving the expression problem using type classes......Page 273
8.4 Summary......Page 277
9 Making concurrent programming easy with actors......Page 278
9.1 What is concurrent programming?......Page 279
9.2.1 Difficulties of shared-state concurrency with threads......Page 281
9.2.2 New trends in concurrency......Page 282
9.3 Implementing message-passing concurrency with actors......Page 283
9.3.1 What is ActorSystem?......Page 285
9.3.2 How do Scala actors work?......Page 287
9.3.3 Divide and conquer using actors......Page 289
9.3.4 Fault tolerance made easy with a supervisor......Page 297
9.4 Composing concurrent programs with Future and Promise......Page 299
9.4.1 Divide and conquer with Future......Page 300
9.4.2 Mixing Future with actors......Page 303
9.6 Summary......Page 304
10 Building confidence with testing......Page 306
10.1 Importance of automated testing......Page 307
10.2 Automated test generation using ScalaCheck......Page 309
10.2.1 Testing the behavior of a string with ScalaCheck......Page 310
10.2.2 ScalaCheck generators......Page 312
10.2.3 Working with ScalaCheck......Page 313
10.3 Test-driven development cycle......Page 317
10.3.2 Using JUnit to test Scala code......Page 319
10.4 Better tests with dependency injection......Page 320
10.4.1 Techniques to implement DI......Page 322
10.4.2 Cake pattern......Page 324
10.4.3 Structural typing......Page 326
10.4.4 Implicit parameters......Page 328
10.4.5 Dependency injection in functional style......Page 329
10.4.6 Using a dependency injection framework: Spring......Page 330
10.5 Behavior-driven development using Specs2......Page 335
10.5.1 Getting started with Specs2......Page 336
10.5.2 Working with specifications......Page 338
10.6 Testing asynchronous messaging systems......Page 340
10.7 Summary......Page 341
Part 3 Advanced steps......Page 344
11 Interoperability between Scala and Java......Page 346
11.1 Using Java classes in Scala......Page 347
11.1.1 Working with Java static members......Page 348
11.1.2 Working with Java checked exceptions......Page 349
11.1.3 Working with Java generics using existential types......Page 350
11.2 Using Scala classes in Java......Page 352
11.2.1 Using Scala annotations......Page 353
11.3 Building web applications in Scala using Java frameworks......Page 355
11.3.1 Building the model, view, and controller......Page 357
11.3.2 Configuring and running the application......Page 363
11.4 Summary......Page 366
12 Scalable and distributed applications using Akka......Page 367
12.1 The philosophy behind Akka......Page 368
12.2 Simple concurrency with Akka......Page 369
12.2.1 Remote actors......Page 370
12.2.2 Making mutable data safe with STM......Page 374
12.2.3 Agents......Page 377
12.2.4 Dataflow......Page 378
12.3 Building a real-time pricing system: Akkaoogle......Page 379
12.3.1 The high-level architecture of Akkaoogle......Page 380
12.3.2 Setting up the project for Akkaoogle......Page 382
12.3.3 Implementing the domain models......Page 383
12.3.4 Implementing the core with actors......Page 387
12.3.5 Increase scalability with remote actors, dispatchers, and routers......Page 391
12.3.6 Handling shared resources with Agent......Page 397
12.4 Adding asynchronous HTTP support with Play2-mini......Page 398
12.4.1 Setting up Play2-mini......Page 399
12.4.2 Running with Play2-mini......Page 400
12.5 Summary......Page 402
A......Page 404
B......Page 405
C......Page 406
D......Page 407
F......Page 408
I......Page 409
M......Page 410
P......Page 411
R......Page 412
S......Page 413
T......Page 415
Z......Page 416