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

Appendix A. References

Abelson, Harold, Gerald Jay Sussman, and Julie Sussman, Structure and Interpretation of Computer Programs. The MIT Press, 1996.

Agha, Gul, Actors. The MIT Press, 1987.

“Akka: Build powerful concurrent & distributed applications more easily,” http://akka.io.

Alexander, Alvin, Scala Cookbook: Recipes for Object-Oriented and Functional Programming. O’Reilly Media, 2013.

Algebird

Allen, Jamie, Effective Akka. O’Reilly Media, 2013.

Antlr

Barr, Michael and Charles Wells, “Category Theory for Computing Science”, 1998.

Behavior-Driven Development

Bloch, Joshua, Effective Java (Second Edition). Addison-Wesley, 2008.

Bird, Richard, Pearls of Functional Algorithm Design. Cambridge University Press, 2010.

Bjarnason, Rúnar Óli, “Stackless Scala and Free Monads”.

Bonér, Jonas, “Real-World Scala: Dependency Injection (DI)”.

Bruce, Kim, Martin Odersky, and Philip Wadler, “A Statically Safe Alternative to Virtual Types,” Proc. ECOOP ’98, E. Jul (Ed.), LNCS 1445, pp. 523–549, Springer-Verlag, 1998.

“Building bug-free O-O software: An introduction to Design by Contract”.

Chiusano, Paul and Rúnar Bjarnason, Functional Programming in Scala. Manning Publications, 2013.

Dean, Jeffrey and Sanjay Ghemawat, “MapReduce: Simplified Data Processing on Large Clusters”.

Dzilums, Lauris, “Awesome Scala”.

Easterbrook, Steve, “An introduction to Category Theory for Software Engineers”.

Eiffel Software

Effective Scala

Evans, Eric, Domain Driven Design. Prentice-Hall, 2003.

Extension Methods ...

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

Appendix A. References

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.