Programming in Scala Second Edition

Transcription

1 Programming in Scala Second Edition Martin Odersky, Lex Spoon, Bill Venners artima ARTIMA PRESS WALNUT CREEK, CALIFORNIA

2 Contents Contents List of Figures List of Tables List of Listings Foreword Foreword to the First Edition Acknowledgments Introduction xüi xxiv xxvi xxviii xxxvii xxxix xli xlv 1 A Scalable Language A language that grows on you What makes Scala scalable? Why Scala? Scala's roots Conclusion 21 2 First Steps in Scala 23 Step 1. Learn to use the Scala interpreter 23 Step 2. Define some variables Step 3. Define some functions 27 Step 4. Write some Scala scripts 29 Step 5. Loop with while; decide with if 30 xm

3 Contents Step 6. Iterate with foreach and for 32 Conclusion 35 3 Next Steps in Scala 37 Step 7. Parameterize arrays with types 37 Step 8. Use lists 41 Step 9. Use tuples 46 Step 10. Use sets and maps 47 Step 11. Learn to recognize the functional style 52 Step 12. Read lines from a file 55 Conclusion 58 4 Classes and Objects Classes, fields, and methods Semicolon inference Singleton objects A Scala application... Y The Application trait Conclusion 72 5 Basic Types and Operations Some basic types Literals Operators are methods Arithmetic operations Relational and logical operations.. s Bitwise operations Object equality Operator precedence and associativity Rich wrappers Conclusion 93 6 Functional Objects ^ A specification for class Rational Constructing a Rational Reimplementing the tostring method Checking preconditions Adding fields 99 xiv

4 6.6 Self references Auxiliary constructors Private fields and methods Defining operators Identifiers in Scala Method overloading Implicit conversions A word of caution Conclusion Built-in Control Structures If expressions While loops For expressions Exception handling with try expressions Match expressions Living without break and continue Variable scope Refactoring imperative-style code Conclusion Functions and Closures Methods Local functions First-class functions Short forms of function literals Placeholder syntax Partially applied functions Closures Special function call forms Tail recursion Conclusion Control Abstraction Reducing code duplication Simplifying client code Currying Writing new control structures 173 xv

5 Contents 9.5 By-name parameters Conclusion Composition and Inheritance A two-dimensional layout library Abstract classes Defining parameterless methods Extending classes Overriding methods and fields Defining parametric fields Invoking superclass constructors Using override modifiers Polymorphism and dynamic binding Declaring final members Using composition and inheritance Implementing above, beside, and tostring Defining a factory object Heighten and widen Putting it all together Conclusion Scala's Hierarchy Scala's class hierarchy How primitives are implemented Bottom types Conclusion Traits How traits work Thin versus rich interfaces Example: Rectangular objects The Ordered trait Traits as stackable modifications Why not multiple inheritance? To trait, or not to trait? Conclusion Packages and Imports 237 xvi

6 13.1 Putting code in packages Concise access to related code Imports Implicit imports Access modifiers Package objects Conclusion Assertions and Unit Testing Assertions Unit testing in Scala Informative failure reports Using JUnit and TestNG Tests as specifications Property-based testing Organizing and running tests Conclusion Case Classes and Pattern Matching A simple example Kinds of patterns Pattern guards Pattern overlaps Sealed classes The Option type Patterns everywhere A larger example Conclusion Working with Lists List literals The List type Constructing lists Basic operations on lists List patterns First-order methods on class List Higher-order methods on class List Methods of the List object 330 xvu

7 Contents 16.9 Processing multiple lists together Understanding Scala's type inference algorithm Conclusion Collections Sequences Sets and maps Selecting mutable versus immutable collections Initializing collections Tuples Conclusion Stateful Objects What makes an object stateful? Reassignable variables and properties Case study: Discrete event simulation A language for digital circuits The Simulation API Circuit Simulation Conclusion Type Parameterization Functional queues Information hiding Variance annotations Checking variance annotations Lower bounds Contravariance Object private data Upper bounds Conclusion Abstract Members A quick tour of abstract members Type members Abstract vals Abstract vars Initializing abstract vals 415 xvin

8 20.6 Abstract types Path-dependent types Structural subtyping Enumerations Case study: Currencies Conclusion Implicit Conversions and Parameters Implicit conversions Rules for implicits Implicit conversion to an expected type Converting the receiver Implicit parameters View bounds When multiple conversions apply Debugging implicits Conclusion Implementing Lists The List class in principle The ListBuff er class The List class in practice Functional on the outside Conclusion For Expressions Revisited For expressions The n-queens problem Querying with for expressions Translation of for expressions Going the other way Generalizing for Conclusion The Scala Collections API Mutable and immutable collections Collections consistency Trait Traversable 502 xix

9 Contents 24.4 Trait It er able The sequence traits Seq, IndexedSeq, and LinearSeq Sets Maps. ( Synchronized sets and maps Concrete immutable collection classes Concrete mutable collection classes Arrays Strings Performance characteristics Equality Views Iterators Creating collections from scratch Conversions between Java and Scala collections Migrating from Scala Conclusion The Architecture of Scala Collections Builders Factoring out common operations Integrating new collections Conclusion Extractors An example: extracting addresses Extractors Patterns with zero or one variables Variable argument extractors Extractors and sequence patterns Extractors versus case classes Regular expressions Conclusion Annotations Why have annotations? Syntax of annotations Standard annotations. 616 xx

10 27.4 Conclusion Working with XML Semi-structured data XML overview XML literals Serialization Taking XML apart Deserialization Loading and saving Pattern matching on XML Conclusion Modular Programming Using Objects The problem A recipe application Abstraction Splitting modules into traits Runtime linking Tracking module instances Conclusion Object Equality Equality in Scala Writing an equality method Defining equality for parameterized types Recipes for equals and hashcode Conclusion Combining Scala and Java Using Scala from Java Annotations Existential types '-.." Using synchronized Compiling Scala and Java together Conclusion Actors and Concurrency 691 xxi

11 Contents 32.1 Trouble in paradise Actors and message passing Treating native threads as actors Better performance through thread reuse Good actors style A longer example: Parallel discrete event simulation Conclusion Combinator Parsing Example: Arithmetic expressions Running your parser Basic regular expression parsers Another example: JSON Parser output Implementing combinator parsers String literals and regular expressions Lexing and parsing Error reporting Backtracking versus LL(1) Conclusion GUI Programming A first Swing application Panels and layouts Handling events Example: Celsius/Fahrenheit converter Conclusion The SCells Spreadsheet The visual framework Disconnecting data entry and display Formulas Parsing formulas Evaluation Operation libraries Change propagation Conclusion 792 xxii

12 A Scala Scripts on Unix and Windows 795 Glossary 797 Bibliography 813 About the Authors 817 Index 819 xxm