Steps in Scala : An Introduction to Object-Functional Programming

"Scala is a highly expressive, concise and scalable language. It is also the most prominent method of the new and exciting methodology known as object-functional programming. In this book, the authors show how Scala grows to the needs of the programmer, whether professional or hobbyist. They teach Scala with a step-by-step approach and explain how to exploit the full power of the industry-proven JVM technology. Readers can then dive into specially chosen design challenges and implementation problems, inspired by the trials of real-world software engineering. It also helps readers to embrace the power of static typing and automatic type inference. In addition, the book shows how to use the dual-object and functional-oriented natures combined at Scala's core, and so write code that is less 'boilerplate', giving a genuine increase in productivity"-- Provided by publisher Cover......Page 1 Half-title......Page 3 Title......Page 5 Copyright......Page 6 Dedication......Page 7 Contents......Page 9 Preface......Page 15 1.1 Object orientation......Page 21 1.2 An overview of functional programming......Page 27 1.3 Extendable languages......Page 29 1.4 Scala: beyond the Java programming language......Page 34 2.1 “HelloWorld!” in Scala......Page 36 2.2 Scala’s basic types......Page 38 2.3 Classes and objects......Page 44 2.4 Some basic operators......Page 49 2.5 Basic built-in control structures......Page 52 2.6 Subclasses and inheritance......Page 58 2.7 Functions......Page 62 2.8 Arrays and tuples......Page 68 2.9 Command line arguments......Page 73 2.10 Sets......Page 76 2.11 Hash tables......Page 79 2.12 Memo functions......Page 82 2.13 Lists......Page 84 2.14 Strings......Page 94 2.15 Regular expressions......Page 96 2.16 Scientific computation with Scala......Page 104 2.17 Inner classes......Page 107 2.18 Packages......Page 108 2.19 Documentation comments......Page 110 2.20 Annotations......Page 112 3.1 Playing with trees......Page 115 3.2.1 Types of patterns......Page 123 3.2.2 Sealed classes......Page 127 3.2.3 Optional values......Page 128 3.3 Traits and mix-in composition......Page 129 3.4 Sorting objects......Page 136 3.5 More on functions......Page 138 3.6.1 Types of polymorphism......Page 145 3.6.2 Overloading......Page 147 3.6.3 Implicit conversion: a form of coercion......Page 148 3.6.4 Parametric polymorphism......Page 151 3.6.5 More on implicit parameters......Page 156 3.6.6 Inclusion polymorphism......Page 157 3.6.7 Covariance, contravariance and invariance......Page 158 3.6.8 Bounded polymorphism......Page 160 3.6.9 Views and view bounds......Page 163 3.6.10 Existential types......Page 164 3.6.12 Type erasure......Page 167 3.7 Nominal and structural typing......Page 168 3.8∗ Higher order polymorphism......Page 170 3.9 Streams are “infinite” lists!......Page 176 3.10∗ More on memo functions......Page 178 3.11 Assertions......Page 179 3.12 Setters and getters......Page 181 3.13∗ Monads......Page 183 4.1 Language parsers......Page 191 4.2 Scala’s parser builders......Page 194 4.3 An interpreter for a toy language......Page 197 4.4 Domain-specific languages......Page 204 4.5 Monadic parsing......Page 205 5.1 What is XML?......Page 207 5.2 Basic XML content manipulation......Page 209 5.3 Producing XHTML content with Scala......Page 213 5.4 XML input and output......Page 216 5.5 XML searching à la Scala......Page 217 5.6 XML pattern matching......Page 219 6.1 “HelloWorld!” again!......Page 222 6.2 Interactive GUI programming......Page 227 6.3 Building a desktop calculator......Page 232 6.4 Simple graphics with Scala......Page 236 6.5 Creating pictorial data......Page 245 6.6 Dialogs......Page 251 6.7.1 Radio buttons......Page 258 6.7.2 Check boxes......Page 260 6.7.3 Combo boxes......Page 263 6.7.4 Building a text editor with a menu bar and menus......Page 270 6.8.1 Simple tabs......Page 277 6.8.2 User-disposable tabs......Page 278 6.8.3 GUI lists, sliders, and split panes......Page 283 6.9 More on text components......Page 286 6.10 Tables......Page 291 6.11 Applets......Page 295 6.12 Functional graphics......Page 300 7.1 Programming with threads: an overview......Page 303 7.2 Animation with threads......Page 309 7.3 Using mailboxes......Page 313 7.4 Actors: basic ideas......Page 315 7.5 Message passing with actors......Page 318 7.6 Computing factorials with actors......Page 323 8 On paths and a bit of algebraic abstraction......Page 327 8.1 Path requirements......Page 328 8.2 Path API......Page 330 8.3 Empty paths......Page 331 8.4 Unix paths......Page 332 8.5 Windows paths......Page 334 8.5.3 Drive absolute paths......Page 335 8.6 Path factory......Page 338 8.6.1 A few more utility methods......Page 340 8.6.2 The factory method......Page 342 8.6.3 Canonical paths......Page 344 8.7 Notes on representation......Page 346 8.9 Testing paths......Page 347 8.9.1 User-friendliness......Page 348 8.10 Algebraic abstractions......Page 349 8.10.1 Semigroups......Page 350 8.10.2 Monoids......Page 351 9 Virtual files coming into existence......Page 354 9.1.2 Design goals......Page 355 9.1.3 VFS API......Page 356 9.1.4 VFile API......Page 359 9.2 Native file system......Page 362 9.3 Memory file system......Page 366 9.3.1 Memory VFS......Page 367 9.3.2 Memory files and folders......Page 368 9.4.1 Preliminaries......Page 371 9.4.2 Zip VFS......Page 374 9.4.4 A VFile that does not exist......Page 377 9.4.5 Zip VFile......Page 378 10.1 Matching files......Page 380 10.2 A less procedural approach......Page 382 10.3 Glob-style matching implementation......Page 387 10.3.1 Remarks on a (non) pure-Scala implementation......Page 390 10.4 Using glob-style matching......Page 391 10.5 Going boolean......Page 396 10.5.1 Less redundancy......Page 397 10.6 Any level down the hierarchy......Page 399 11.1.1 Iterables......Page 400 11.1.2 Traversables......Page 401 11.1.3 Test trees and expected search results......Page 402 Depth-first search......Page 403 11.2.1 The shape of our data......Page 405 Subtle type inferring issues......Page 407 Can we do better than wrapping?......Page 408 Children provisioning......Page 409 Iteration from the inside......Page 410 11.3 Traversing the hierarchy......Page 417 User-directed versus collection-directed......Page 419 Object-oriented or functional......Page 420 Interchangeability between approaches......Page 421 12.1 Introduction......Page 422 Data-centric decomposition......Page 423 Operation-centric decomposition......Page 424 12.3 Data-centric approach with subclassing......Page 427 Automatic instance transformations......Page 428 On the constructor of ReprPlusD......Page 429 12.4 Operation-centric approach with subclassing......Page 430 12.5 Generic operation-centric approach......Page 432 12.6 Generic data-centric approach......Page 435 12.7 OO decomposition with abstract types......Page 437 Adding new data......Page 438 Adding new operations......Page 439 12.8 Operation-centric decomposition with abstract types......Page 441 Adding new operations......Page 443 12.9 Summary......Page 444 13.1 Mechanical symbol manipulation......Page 446 13.2 The grammar......Page 447 13.3 Basic data model......Page 448 13.4 Experimenting with the data model......Page 449 13.5.1 Finding the derivative of a function......Page 450 13.5.2 Simplifying an expression......Page 452 13.5.3 Pretty-printing expressions......Page 453 13.6 Putting it all together......Page 456 13.8 Summary and further reading......Page 457 Appendix A: Multimedia processing......Page 459 B.1 Introduction......Page 461 B.3 Requirement and candidate application......Page 462 B.4 Proguard configuration......Page 465 B.5 Trading space for time......Page 467 Version of scalac......Page 469 Debugging Info......Page 470 Verbosity......Page 471 Class paths......Page 472 Explain type errors......Page 473 Advanced options related to compiler phases......Page 474 Other advanced options......Page 479 The private/experimental -Y options......Page 480 C.2 The Scala interpreter......Page 482 D.1 Lexical entities......Page 483 D.2 The rest of the language......Page 484 References......Page 490 Name index......Page 494 Subject index......Page 495 Machine generated contents note: Preface; 1. Introduction; 2. Core features; 3. Advanced features; 4. Parser builders; 5. XML processing; 6. GUI programming; 7. Concurrent programming; 8. On paths and a bit of algebraic abstractions; 9. Virtual files coming into existence; 10. Compositional file matching; 11. Searching, iterating, traversing; 12. The expression problem; 13. A computer algebra system; Appendix A. Multimedia processing; Appendix B. Distributing a Scala application along with Scala itself; Appendix C. Working with the compiler and the interpreter; Appendix D. Scala's grammar; References; Author index; Subject index. A hands-on introduction to Scala, the first fully-fledged programming language to embody the principles and ideas of object-functional programming. Highly expressive, concise and scalable, Scala grows to the needs of a programmer, whether professional or hobbyist. The book includes carefully chosen exercises and three full programming projects.