book

Programming Scala, 3rd Edition

Name: Programming Scala, 3rd Edition
Author: Dean Wampler
ISBN: 9781492077893

by Dean Wampler

May 2021

Intermediate to advanced

553 pages

13h 45m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Foreword
Foreword, Third EditionForeword, First and Second Edition
Preface
Welcome to Programming Scala, Third EditionHow to Read This BookWelcome to Programming Scala, Second EditionWelcome to Programming Scala, First EditionConventions Used in This BookUsing Code ExamplesGetting the Code ExamplesO’Reilly Online LearningHow to Contact UsAcknowledgments for the Third EditionAcknowledgments for the Second EditionAcknowledgments for the First Edition
1. Zero to Sixty: Introducing Scala
Why Scala?The Appeal of ScalaWhy Scala 3?Migrating to Scala 3Installing the Scala Tools You NeedBuilding the Code ExamplesMore TipsUsing sbtRunning the Scala Command-Line Tools Using sbtA Taste of ScalaA Sample ApplicationRecap and What’s Next
2. Type Less, Do More
New Scala 3 Syntax—Optional BracesSemicolonsVariable DeclarationsRangesPartial FunctionsMethod DeclarationsMethod Default and Named ParametersMethods with Multiple Parameter ListsNesting Method Definitions and RecursionInferring Type InformationRepeated Parameter ListsLanguage KeywordsLiteral ValuesNumeric LiteralsBoolean LiteralsCharacter LiteralsString LiteralsSymbol LiteralsFunction LiteralsTuplesOption, Some, and None: Avoiding NullsWhen You Really Can’t Avoid NullsSealed Class Hierarchies and EnumerationsOrganizing Code in Files and NamespacesImporting Types and Their MembersPackage Imports and Package ObjectsParameterized Types Versus Abstract Type MembersRecap and What’s Next
3. Rounding Out the Basics
Defining OperatorsAllowed Characters in IdentifiersMethods with Empty Parameter ListsOperator Precedence RulesEnumerations and Algebraic Data TypesInterpolated StringsScala Conditional ExpressionsConditional and Comparison Operatorsfor Comprehensionsfor LoopsGeneratorsGuards: Filtering ValuesYielding New ValuesExpanded Scope and Value DefinitionsScala while LoopsUsing try, catch, and finally ClausesCall by Name, Call by ValueLazy ValuesTraits: Interfaces and Mixins in ScalaWhen new Is OptionalRecap and What’s Next
4. Pattern Matching
Safer Pattern Matching with MatchableValues, Variables, and Types in MatchesMatching on SequencesPattern Matching on Repeated ParametersMatching on TuplesParameter UntuplingGuards in Case ClausesMatching on Case Classes and EnumsMatching on Regular ExpressionsMatching on Interpolated StringsSealed Hierarchies and Exhaustive MatchesChaining Match ExpressionsPattern Matching Outside Match ExpressionsProblems in Pattern BindingsPattern Matching as Filtering in for ComprehensionsPattern Matching and ErasureExtractorsunapply MethodAlternatives to Option Return ValuesunapplySeq MethodImplementing unapplySeqRecap and What’s Next
5. Abstracting Over Context: Type Classes and Extension Methods
Four ChangesExtension MethodsBuild Your Own String InterpolatorType ClassesScala 3 Type ClassesAlias GivensScala 2 Type ClassesScala 3 Implicit ConversionsType Class DerivationGivens and ImportsGivens Scoping and Pattern MatchingResolution Rules for Givens and Extension MethodsThe Expression ProblemRecap and What’s Next
6. Abstracting Over Context: Using Clauses
Using ClausesContext BoundsOther Context ParametersContext FunctionsConstraining Allowed InstancesImplicit EvidenceWorking Around Type Erasure with Using ClausesRules for Using ClausesImproving Error MessagesRecap and What’s Next
7. 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 OptimizationPartially Applied Functions Versus Partial FunctionsCurrying and Uncurrying FunctionsTupled and Untupled FunctionsPartial Functions Versus Functions Returning OptionsFunctional Data StructuresSequencesMapsSetsTraversing, Mapping, Filtering, Folding, and ReducingTraversingMappingFlat MappingFilteringFolding and ReducingLeft Versus Right FoldingCombinators: Software’s Best Component AbstractionsWhat About Making Copies?Recap and What’s Next
8. for Comprehensions in Depth
Recap: The Elements of for Comprehensionsfor Comprehensions: Under the HoodTranslation Rules of for ComprehensionsOptions and Container TypesOption as a Container?Either: An Alternative to OptionTry: When There Is No DoValidated from the Cats LibraryRecap and What’s Next

9. Object-Oriented Programming in Scala
Class and Object Basics: ReviewOpen Versus Closed TypesClasses Open for ExtensionOverriding Methods? The Template Method PatternReference Versus Value TypesOpaque Types and Value ClassesOpaque Type AliasesValue ClassesSupertypesConstructors in ScalaCalling Supertype ConstructorsExport ClausesGood Object-Oriented Design: A DigressionFields in TypesThe Uniform Access PrincipleUnary MethodsRecap and What’s Next
10. Traits
Traits as MixinsStackable TraitsUnion and Intersection TypesTransparent TraitsUsing Commas Instead of withTrait ParametersShould That Type Be a Class or Trait?Recap and What’s Next
11. Variance Behavior and Equality
Parameterized Types: Variance Under InheritanceFunctions Under the HoodVariance of Mutable TypesImproper Variance of Java ArraysEquality of InstancesThe equals MethodThe == and != MethodsThe eq and ne MethodsArray Equality and the sameElements MethodEquality and InheritanceMultiversal EqualityCase Objects and hashCodeRecap and What’s Next
12. Instance Initialization and Method Resolution
Linearization of a Type HierarchyInitializing Abstract FieldsOverriding Concrete FieldsAbstract Type Members and Concrete Type AliasesRecap and What’s Next
13. The Scala Type Hierarchy
Much Ado About Nothing (and Null)The scala PackageProducts, Case Classes, Tuples, and FunctionsTuples and the Tuple TraitThe Predef ObjectImplicit ConversionsType DefinitionsCondition Checking MethodsInput and Output MethodsMiscellaneous MethodsRecap and What’s Next
14. The Scala Collections Library
Different Groups of CollectionsAbstractions with Multiple ImplementationsThe scala.collection.immutable PackageThe scala.collection.mutable PackageThe scala.collection PackageThe scala.collection.concurrent PackageThe scala.collection.convert PackageThe scala.collection.generic PackageConstruction of InstancesThe Iterable AbstractionPolymorphic MethodsEquality for CollectionsNonstrict Collections: ViewsRecap and What’s Next
15. Visibility Rules
Public Visibility: The DefaultVisibility KeywordsProtected VisibilityPrivate VisibilityScoped Private and Protected VisibilityRecap and What’s Next
16. Scala’s Type System, Part I
Parameterized TypesAbstract Type Members and Concrete Type AliasesComparing Abstract Type Members Versus Parameterized TypesType BoundsUpper Type BoundsLower Type BoundsContext BoundsView BoundsIntersection and Union TypesIntersection TypesUnion TypesPhantom TypesStructural TypesRefined TypesExistential Types (Obsolete)Recap and What’s Next
17. Scala’s Type System, Part II
Match TypesDependently Typed MethodsDependent Method and Dependent Function TypesDependent TypingPath-Dependent TypesUsing thisUsing superStable PathsSelf-Type DeclarationsType ProjectionsMore on Singleton TypesSelf-Recursive Types: F-Bounded PolymorphismHigher-Kinded TypesType LambdasPolymorphic FunctionsType Wildcard Versus PlaceholderRecap and What’s Next
18. Advanced Functional Programming
Algebraic Data TypesSum Types Versus Product TypesProperties of Algebraic Data TypesFinal Thoughts on Algebraic Data TypesCategory TheoryWhat Is a Category?FunctorThe Monad EndofunctorThe Semigroup and Monoid CategoriesRecap and What’s Next
19. Tools for Concurrency
The scala.sys.process PackageFuturesRobust, Scalable Concurrency with ActorsAkka: Actors for ScalaActors: Final ThoughtsStream ProcessingRecap and What’s Next
20. Dynamic Invocation in Scala
Structural Types RevisitedA Motivating Example: ActiveRecord in Ruby on RailsDynamic Invocation with the Dynamic TraitDSL ConsiderationsRecap and What’s Next
21. Domain-Specific Languages in Scala
Internal DSLsExternal DSLs with Parser CombinatorsAbout Parser CombinatorsA Payroll External DSLInternal Versus External DSLs: Final ThoughtsRecap and What’s Next
22. Scala Tools and Libraries
Scala 3 VersionsCommand-Line Interface ToolsCoursierManaging Java JDKs with CoursierThe scalac Command-Line ToolThe scala Command-Line ToolThe scaladoc Command-Line ToolOther Scala Command-Line ToolsBuild ToolsIntegration with IDEs and Text EditorsUsing Notebook Environments with ScalaTesting ToolsScala for Big Data: Apache SparkTypelevel LibrariesLi Haoyi LibrariesJava and Scala InteroperabilityUsing Java Identifiers in Scala CodeScala Identifiers in Java CodeJava Generics and Scala Parameterized TypesConversions Between Scala and Java CollectionsJava Lambdas Versus Scala FunctionsAnnotations for JavaBean Properties and Other PurposesRecap and What’s Next
23. Application Design
Recap of What We Already KnowAnnotationsUsing @main Entry PointsDesign PatternsCreational PatternsStructural PatternsBehavioral PatternsBetter Design with Design by ContractThe Parthenon ArchitectureRecap and What’s Next
24. Metaprogramming: Macros and Reflection
Scala Compile Time ReflectionJava Runtime ReflectionScala Reflect APIType Class Derivation: Implementation DetailsScala 3 MetaprogrammingInlineMacrosStagingWrapping Up and Looking Ahead
A. Significant Indentation Versus Braces Syntax
Bibliography
Index

Overview

Get up to speed on Scala--the JVM, JavaScript, and natively compiled language that offers all the benefits of functional programming, a modern object model, and an advanced type system. Packed with code examples, this comprehensive book shows you how to be productive with the language and ecosystem right away. You'll learn why Scala is ideal for building today's highly scalable, data-centric applications, while maximizing developer productivity.

While Java remains popular and Kotlin has become popular, Scala hasn't been sitting still. This third edition covers the new features in Scala 3.0 with updates throughout the book. Programming Scala is ideal for beginning to advanced developers who want a complete understanding of Scala's design philosophy and features with a thoroughly practical focus.

Program faster with Scala's succinct and flexible syntax
Dive into basic and advanced functional programming techniques
Build killer big data and distributed apps using Scala's functional combinators and tools like Spark and Akka
Create concise solutions to challenging design problems with the sophisticated type system, mixin composition with traits, pattern matching, and more

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: 9781492077886Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills