book

Programming Scala, 2nd Edition

by Dean Wampler, Alex Payne

December 2014

Intermediate to advanced

598 pages

14h 36m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Foreword
Preface
Welcome to Programming Scala, Second EditionHow to Read This BookWhat Isn’t Covered?Welcome to Programming Scala, First EditionConventions Used in This BookUsing Code ExamplesGetting the Code ExamplesO’Reilly SafariHow to Contact UsAcknowledgments for the Second EditionAcknowledgments for the First Edition
1. Zero to Sixty: Introducing Scala
Why Scala?The Seductions of ScalaWhat About Java 8?Installing ScalaUsing SBTRunning the Scala Command-Line ToolsRunning the Scala REPL in IDEsA Taste of ScalaA Taste of ConcurrencyRecap and What’s Next
2. Type Less, Do More
SemicolonsVariable DeclarationsRangesPartial FunctionsMethod DeclarationsMethod Default and Named ArgumentsMethods with Multiple Argument ListsA Taste of FuturesNesting Method Definitions and RecursionInferring Type InformationReserved WordsLiteral ValuesInteger LiteralsFloating-Point LiteralsBoolean LiteralsCharacter LiteralsString LiteralsSymbol LiteralsFunction LiteralsTuple LiteralsOption, Some, and None: Avoiding nullsSealed Class HierarchiesOrganizing Code in Files and NamespacesImporting Types and Their MembersImports Are RelativePackage ObjectsAbstract Types Versus Parameterized TypesRecap and What’s Next
3. Rounding Out the Basics
Operator Overloading?Syntactic SugarMethods with Empty Argument ListsPrecedence RulesDomain-Specific LanguagesScala if StatementsScala for Comprehensionsfor LoopsGenerator ExpressionsGuards: Filtering ValuesYieldingExpanded Scope and Value DefinitionsOther Looping ConstructsScala while LoopsScala do-while LoopsConditional OperatorsUsing try, catch, and finally ClausesCall by Name, Call by Valuelazy valEnumerationsInterpolated StringsTraits: Interfaces and “Mixins” in ScalaRecap and What’s Next
4. Pattern Matching
A Simple MatchValues, Variables, and Types in MatchesMatching on SequencesMatching on TuplesGuards in case ClausesMatching on case Classesunapply MethodunapplySeq MethodMatching on Variable Argument ListsMatching on Regular ExpressionsMore on Binding Variables in case ClausesMore on Type MatchingSealed Hierarchies and Exhaustive MatchesOther Uses of Pattern MatchingConcluding Remarks on Pattern MatchingRecap and What’s Next
5. Implicits
Implicit ArgumentsUsing implicitlyScenarios for Implicit ArgumentsExecution ContextsCapabilitiesConstraining Allowed InstancesImplicit EvidenceWorking Around ErasureImproving Error MessagesPhantom TypesRules for Implicit ArgumentsImplicit ConversionsBuild Your Own String InterpolatorThe Expression ProblemType Class PatternTechnical Issues with ImplicitsImplicit Resolution RulesScala’s Built-in ImplicitsWise Use of ImplicitsRecap and What’s Next
6. Functional Programming in Scala
What Is Functional Programming?Functions in MathematicsVariables That Aren’tFunctional Programming in ScalaAnonymous Functions, Lambdas, and ClosuresPurity Inside Versus OutsideRecursionTail Calls and Tail-Call OptimizationTrampoline for Tail CallsPartially Applied Functions Versus Partial FunctionsCurrying and Other Transformations on FunctionsFunctional Data StructuresSequencesMapsSetsTraversing, Mapping, Filtering, Folding, and ReducingTraversalMappingFlat MappingFilteringFolding and ReducingLeft Versus Right TraversalsTail Recursion Versus Traversals of Infinite CollectionsCombinators: Software’s Best Component AbstractionsWhat About Making Copies?Recap and What’s Next
7. for Comprehensions in Depth
Recap: The Elements of for Comprehensionsfor Comprehensions: Under the HoodTranslation Rules of for ComprehensionsOptions and Other Container TypesOption as a ContainerEither: A Logical Extension to OptionTry: When There Is No DoScalaz ValidationRecap and What’s Next
8. Object-Oriented Programming in Scala
Class and Object BasicsReference Versus Value TypesValue ClassesParent TypesConstructors in ScalaFields in ClassesThe Uniform Access PrincipleUnary MethodsValidating InputCalling Parent Class Constructors (and Good Object-Oriented Design)Good Object-Oriented Design: A DigressionNested TypesRecap and What’s Next

9. Traits
Interfaces in Java 8Traits as MixinsStackable TraitsConstructing TraitsClass or Trait?Recap and What’s Next
10. The Scala Object System, Part I
Parameterized Types: Variance Under InheritanceFunctions Under the HoodVariance of Mutable TypesVariance in Scala Versus JavaThe Scala Type HierarchyMuch Ado About Nothing (and Null)Products, Case Classes, and TuplesThe Predef ObjectImplicit ConversionsType DefinitionsCondition Checking MethodsInput and Output MethodsMiscellaneous MethodsEquality of ObjectsThe equals MethodThe == and != MethodsThe eq and ne MethodsArray Equality and the sameElements MethodRecap and What’s Next
11. The Scala Object System, Part II
Overriding Members of Classes and TraitsAvoid Overriding Concrete MembersAttempting to Override final DeclarationsOverriding Abstract and Concrete MethodsOverriding Abstract and Concrete FieldsOverriding Abstract TypesWhen Accessor Methods and Fields Are Indistinguishable: The Uniform Access PrincipleLinearization of an Object’s HierarchyRecap and What’s Next
12. The Scala Collections Library
Generic, Mutable, Immutable, Concurrent, and Parallel Collections, Oh My!The scala.collection PackageThe collection.concurrent PackageThe collection.convert PackageThe collection.generic PackageThe collection.immutable PackageThe scala.collection.mutable PackageThe scala.collection.parallel PackageChoosing a CollectionDesign Idioms in the Collections LibraryBuilderCanBuildFromLike TraitsSpecialization for Value TypesMiniboxingRecap and What’s Next
13. Visibility Rules
Public Visibility: The DefaultVisibility KeywordsPublic VisibilityProtected VisibilityPrivate VisibilityScoped Private and Protected VisibilityFinal Thoughts on VisibilityRecap and What’s Next
14. Scala’s Type System, Part I
Parameterized TypesVariance AnnotationsType ConstructorsType Parameter NamesType BoundsUpper Type BoundsLower Type BoundsContext BoundsView BoundsUnderstanding Abstract TypesComparing Abstract Types and Parameterized TypesSelf-Type AnnotationsStructural TypesCompound TypesType RefinementsExistential TypesRecap and What’s Next
15. Scala’s Type System, Part II
Path-Dependent TypesC.thisC.superpath.xDependent Method TypesType ProjectionsSingleton TypesTypes for ValuesTuple TypesFunction TypesInfix TypesHigher-Kinded TypesType LambdasSelf-Recursive Types: F-Bounded PolymorphismRecap and What’s Next
16. Advanced Functional Programming
Algebraic Data TypesSum Types Versus Product TypesProperties of Algebraic Data TypesFinal Thought on Algebraic Data TypesCategory TheoryAbout CategoriesThe Functor CategoryThe Monad CategoryThe Importance of MonadRecap and What’s Next
17. Tools for Concurrency
The scala.sys.process PackageFuturesAsyncRobust, Scalable Concurrency with ActorsAkka: Actors for ScalaActors: Final ThoughtsPickling and SporesReactive ProgrammingRecap and What’s Next
18. Scala for Big Data
Big Data: A Brief HistoryImproving MapReduce with ScalaMoving Beyond MapReduceCategories for MathematicsA List of Scala-Based Data ToolsRecap and What’s Next
19. Dynamic Invocation in Scala
A Motivating Example: ActiveRecord in Ruby on RailsDynamic Invocation in Scala with the Dynamic TraitDSL ConsiderationsRecap and What’s Next
20. Domain-Specific Languages in Scala
Examples: XML and JSON DSLs for ScalaInternal DSLsExternal DSLs with Parser CombinatorsAbout Parser CombinatorsA Payroll External DSLInternal Versus External DSLs: Final ThoughtsRecap and What’s Next
21. Scala Tools and Libraries
Command-Line Toolsscalac Command-Line ToolThe scala Command-Line ToolThe scalap and javap Command-Line ToolsThe scaladoc Command-Line ToolThe fsc Command-Line ToolBuild ToolsSBT, the Standard Build Tool for ScalaOther Build ToolsIntegration with IDEs and Text EditorsText EditorsTest-Driven Development in ScalaThird-Party LibrariesRecap and What’s Next
22. Java Interoperability
Using Java Names in Scala CodeJava and Scala GenericsJavaBean PropertiesAnyVal Types and Java PrimitivesScala Names in Java CodeRecap and What’s Next
23. Application Design
Recap of What We Already KnowAnnotationsTraits as ModulesDesign PatternsCreational PatternsStructural PatternsBehavioral PatternsBetter Design with Design by ContractThe Parthenon ArchitectureRecap and What’s Next
24. Metaprogramming: Macros and Reflection
Tools for Understanding TypesRuntime ReflectionReflecting on TypesClass Tags, Type Tags, and ManifestsScala’s Advanced Runtime Reflection APIMacrosA Macro Example: Enforcing InvariantsFinal Thoughts on MacrosWrapping Up and Looking Ahead
A. References
Index

Content preview from Programming Scala, 2nd Edition

Preface

Programming Scala introduces an exciting and powerful language that offers all the benefits of a modern object model, functional programming (FP), and an advanced type system, while leveraging the industry’s investment in the Java Virtual Machine (JVM). Packed with code examples, this comprehensive book teaches you how to be productive with Scala quickly, and explains what makes this language ideal for today’s scalable, distributed, component-based applications that support concurrency and distribution. You’ll also learn how Scala takes advantage of the advanced JVM as a platform for programming languages.

Learn more at http://programming-scala.org or at the book’s catalog page.

Welcome to Programming Scala, Second Edition

Programming Scala, First Edition was published five years ago, in the fall of 2009. At the time, it was only the third book dedicated to Scala, and it just missed being the second by a few months. Scala version 2.7.5 was the official release, with version 2.8.0 nearing completion.

A lot has changed since then. At the time of this writing, the Scala version is 2.11.2. Martin Odersky, the creator of Scala, and Jonas Bonér, the creator of Akka, an actor-based concurrency framework, cofounded Typesafe to promote the language and tools built on it.

There are also a lot more books about Scala. So, do we really need a second edition of this book? Many excellent beginner’s guides to Scala are now available. A few advanced books have emerged. The encyclopedic ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781491950135Purchase book Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Programming Scala, 2nd Edition

by Dean Wampler, Alex Payne

Preface

Welcome to Programming Scala, Second Edition

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.