Scala for the Impatient

Scala for the Impatient

Paperback

By (author) Cay S. Horstmann

$31.48
List price $43.72
You save $12.24 27% off

Free delivery worldwide
Available
Dispatched in 3 business days
When will my order arrive?

  • Publisher: Addison-Wesley Educational Publishers Inc
  • Format: Paperback | 384 pages
  • Dimensions: 178mm x 231mm x 23mm | 499g
  • Publication date: 16 March 2012
  • Publication City/Country: New Jersey
  • ISBN 10: 0321774094
  • ISBN 13: 9780321774095
  • Edition: Annotated
  • Edition statement: New.
  • Sales rank: 65,280

Product description

Scala is a modern programming language for the Java Virtual Machine (JVM) that combines the best features of object-oriented and functional programming languages. Using Scala, you can write programs more concisely than in Java, as well as leverage the full power of concurrency. Since Scala runs on the JVM, it can access any Java library and is interoperable with Java frameworks. Scala for the Impatient concisely shows developers what Scala can do and how to do it. In this book, Cay Horstmann, the principal author of the international best-selling Core Java(TM), offers a rapid, code-based introduction that's completely practical. Horstmann introduces Scala concepts and techniques in "blog-sized" chunks that you can quickly master and apply. Hands-on activities guide you through well-defined stages of competency, from basic to expert. Coverage includes * Getting started quickly with Scala's interpreter, syntax, tools, and unique idioms * Mastering core language features: functions, arrays, maps, tuples, packages, imports, exception handling, and more * Becoming familiar with object-oriented programming in Scala: classes, inheritance, and traits * Using Scala for real-world programming tasks: working with files, regular expressions, and XML * Working with higher-order functions and the powerful Scala collections library * Leveraging Scala's powerful pattern matching and case classes * Creating concurrent programs with Scala actors * Implementing domain-specific languages * Understanding the Scala type system * Applying advanced "power tools" such as annotations, implicits, and delimited continuations Scala is rapidly reaching a tipping point that will reshape the experience of programming. This book will help object-oriented programmers build on their existing skills, allowing them to immediately construct useful applications as they gradually master advanced programming techniques.

Other people who viewed this bought:

Showing items 1 to 10 of 10

Other books in this category

Showing items 1 to 10 of 10
Categories:

Author information

Cay S. Horstmann is principal author of Core Java(TM), Volumes I and II, Eighth Edition (Prentice Hall, 2008), as well as a dozen other books for professional programmers and computer science students. He is a professor of computer science at San Jose State University and a Java Champion.

Table of contents

Foreword xvii Preface xix About the Author xxi Chapter 1: The Basics 1 1.1 The Scala Interpreter 1 1.2 Declaring Values and Variables 3 1.3 Commonly Used Types 4 1.4 Arithmetic and Operator Overloading 5 1.5 Calling Functions and Methods 7 1.6 The apply Method 8 1.7 Scaladoc 8 Exercises 11 Chapter 2: Control Structures and Functions 13 2.1 Conditional Expressions 14 2.2 Statement Termination 15 2.3 Block Expressions and Assignments 16 2.4 Input and Output 17 2.5 Loops 18 2.6 Advanced for Loops and for Comprehensions 19 2.7 Functions 20 2.8 Default and Named Arguments 21 2.9 Variable Arguments 22 2.10 Procedures 23 2.11 Lazy Values 23 2.12 Exceptions 24 Exercises 26 Chapter 3: Working with Arrays 29 3.1 Fixed-Length Arrays 29 3.2 Variable-Length Arrays: Array Buffers 30 3.3 Traversing Arrays and Array Buffers 31 3.4 Transforming Arrays 32 3.5 Common Algorithms 34 3.6 Deciphering Scaladoc 35 3.7 Multidimensional Arrays 37 3.8 Interoperating with Java 37 Exercises 38 Chapter 4: Maps and Tuples 41 4.1 Constructing a Map 41 4.2 Accessing Map Values 42 4.3 Updating Map Values 43 4.4 Iterating over Maps 43 4.5 Sorted Maps 44 4.6 Interoperating with Java 44 4.7 Tuples 45 4.8 Zipping 46 Exercises 46 Chapter 5: Classes 49 5.1 Simple Classes and Parameterless Methods 49 5.2 Properties with Getters and Setters 50 5.3 Properties with Only Getters 53 5.4 Object-Private Fields 54 5.5 Bean Properties 55 5.6 Auxiliary Constructors 56 5.7 The Primary Constructor 57 5.8 Nested Classes 60 Exercises 63 Chapter 6: Objects 65 6.1 Singletons 65 6.2 Companion Objects 66 6.3 Objects Extending a Class or Trait 67 6.4 The apply Method 67 6.5 Application Objects 68 6.6 Enumerations 69 Exercises 71 Chapter 7: Packages and Imports 73 7.1 Packages 74 7.2 Scope Rules 75 7.3 Chained Package Clauses 77 7.4 Top-of-File Notation 77 7.5 Package Objects 78 7.6 Package Visibility 78 7.7 Imports 79 7.8 Imports Can Be Anywhere 80 7.9 Renaming and Hiding Members 80 7.10 Implicit Imports 80 Exercises 81 Chapter 8: Inheritance 85 8.1 Extending a Class 85 8.2 Overriding Methods 86 8.3 Type Checks and Casts 87 8.4 Protected Fields and Methods 88 8.5 Superclass Construction 88 8.6 Overriding Fields 89 8.7 Anonymous Subclasses 91 8.8 Abstract Classes 91 8.9 Abstract Fields 91 8.10 Construction Order and Early Definitions 92 8.11 The Scala Inheritance Hierarchy 94 8.12 Object Equality 95 Exercises 96 Chapter 9: Files and Regular Expressions 99 9.1 Reading Lines 100 9.2 Reading Characters 100 9.3 Reading Tokens and Numbers 101 9.4 Reading from URLs and Other Sources 102 9.5 Reading Binary Files 102 9.6 Writing Text Files 102 9.7 Visiting Directories 103 9.8 Serialization 104 9.9 Process Control 105 9.10 Regular Expressions 106 9.11 Regular Expression Groups 107 Exercises 107 Chapter 10: Traits 111 10.1 Why No Multiple Inheritance? 111 10.2 Traits as Interfaces 113 10.3 Traits with Concrete Implementations 114 10.4 Objects with Traits 115 10.5 Layered Traits 116 10.6 Overriding Abstract Methods in Traits 117 10.7 Traits for Rich Interfaces 118 10.8 Concrete Fields in Traits 118 10.9 Abstract Fields in Traits 119 10.10 Trait Construction Order 120 10.11 Initializing Trait Fields 122 10.12 Traits Extending Classes 123 10.13 Self Types 124 10.14 What Happens under the Hood 125 Exercises 127 Chapter 11: Operators 131 11.1 Identifiers 131 11.2 Infix Operators 132 11.3 Unary Operators 133 11.4 Assignment Operators 133 11.5 Precedence 134 11.6 Associativity 135 11.7 The apply and update Methods 135 11.8 Extractors 136 11.9 Extractors with One or No Arguments 138 11.10 The unapplySeq Method 138 Exercises 139 Chapter 12: Higher-Order Functions 143 12.1 Functions as Values 143 12.2 Anonymous Functions 144 12.3 Functions with Function Parameters 145 12.4 Parameter Inference 146 12.5 Useful Higher-Order Functions 146 12.6 Closures 148 12.7 SAM Conversions 149 12.8 Currying 149 12.9 Control Abstractions 150 12.10 The return Expression 152 Exercises 152 Chapter 13: Collections 155 13.1 The Main Collections Traits 156 13.2 Mutable and Immutable Collections 157 13.3 Sequences 158 13.4 Lists 159 13.5 Mutable Lists 160 13.6 Sets 161 13.7 Operators for Adding or Removing Elements 162 13.8 Common Methods 164 13.9 Mapping a Function 167 13.10 Reducing, Folding, and Scanning 168 13.11 Zipping 171 13.12 Iterators 172 13.13 Streams 173 13.14 Lazy Views 174 13.15 Interoperability with Java Collections 175 13.16 Threadsafe Collections 177 13.17 Parallel Collections 178 Exercises 179 Chapter 14: Pattern Matching and Case Classes 183 14.1 A Better Switch 184 14.2 Guards 185 14.3 Variables in Patterns 185 14.4 Type Patterns 186 14.5 Matching Arrays, Lists, and Tuples 187 14.6 Extractors 188 14.7 Patterns in Variable Declarations 188 14.8 Patterns in for Expressions 189 14.9 Case Classes 189 14.10 The copy Method and Named Parameters 190 14.11 Infix Notation in case Clauses 191 14.12 Matching Nested Structures 192 14.13 Are Case Classes Evil? 192 14.14 Sealed Classes 193 14.15 Simulating Enumerations 194 14.16 The Option Type 194 14.17 Partial Functions 195 Exercises 196 Chapter 15: Annotations 199 15.1 What Are Annotations? 200 15.2 What Can Be Annotated? 200 15.3 Annotation Arguments 201 15.4 Annotation Implementations 202 15.5 Annotations for Java Features 203 15.6 Annotations for Optimizations 206 15.7 Annotations for Errors and Warnings 210 Exercises 211 Chapter 16: XML Processing 213 16.1 XML Literals 214 16.2 XML Nodes 214 16.3 Element Attributes 216 16.4 Embedded Expressions 217 16.5 Expressions in Attributes 218 16.6 Uncommon Node Types 219 16.7 XPath-like Expressions 220 16.8 Pattern Matching 221 16.9 Modifying Elements and Attributes 222 16.10 Transforming XML 223 16.11 Loading and Saving 223 16.12 Namespaces 226 Exercises 227 Chapter 17: Type Parameters 231 17.1 Generic Classes 232 17.2 Generic Functions 232 17.3 Bounds for Type Variables 232 17.4 View Bounds 234 17.5 Context Bounds 234 17.6 The Manifest Context Bound 235 17.7 Multiple Bounds 235 17.8 Type Constraints 236 17.9 Variance 237 17.10 Co- and Contravariant Positions 238 17.11 Objects Can't Be Generic 240 17.12 Wildcards 241 Exercises 241 Chapter 18: Advanced Types 245 18.1 Singleton Types 246 18.2 Type Projections 247 18.3 Paths 248 18.4 Type Aliases 249 18.5 Structural Types 250 18.6 Compound Types 250 18.7 Infix Types 251 18.8 Existential Types 252 18.9 The Scala Type System 253 18.10 Self Types 254 18.11 Dependency Injection 255 18.12 Abstract Types 257 18.13 Family Polymorphism 259 18.14 Higher-Kinded Types 263 Exercises 265 Chapter 19: Parsing 269 19.1 Grammars 270 19.2 Combining Parser Operations 271 19.3 Transforming Parser Results 273 19.4 Discarding Tokens 274 19.5 Generating Parse Trees 275 19.6 Avoiding Left Recursion 276 19.7 More Combinators 277 19.8 Avoiding Backtracking 280 19.9 Packrat Parsers 280 19.10 What Exactly Are Parsers? 281 19.11 Regex Parsers 282 19.12 Token-Based Parsers 283 19.13 Error Handling 285 Exercises 286 Chapter 20: Actors 289 20.1 Creating and Starting Actors 290 20.2 Sending Messages 291 20.3 Receiving Messages 292 20.4 Sending Messages to Other Actors 293 20.5 Channels 294 20.6 Synchronous Messages and Futures 295 20.7 Thread Sharing 296 20.8 The Actor Life Cycle 299 20.9 Linking Actors 300 20.10 Designing with Actors 301 Exercises 302 Chapter 21: Implicits 305 21.1 Implicit Conversions 306 21.2 Using Implicits for Enriching Existing Libraries 306 21.3 Importing Implicits 307 21.4 Rules for Implicit Conversions 308 21.5 Implicit Parameters 309 21.6 Implicit Conversions with Implicit Parameters 310 21.7 Context Bounds 311 21.8 Evidence 312 21.9 The @implicitNotFound Annotation 313 21.10 CanBuildFrom Demystified 314 Exercises 316 Chapter 22: Delimited Continuations 319 22.1 Capturing and Invoking a Continuation 320 22.2 The "Computation with a Hole" 321 22.3 The Control Flow of reset and shift 322 22.4 The Value of a reset Expression 323 22.5 The Types of reset and shift Expressions 323 22.6 CPS Annotations 325 22.7 Turning a Recursive Visit into an Iteration 326 22.8 Undoing Inversion of Control 329 22.9 The CPS Transformation 332 22.10 Transforming Nested Control Contexts 334 Exercises 336 Index 339