book

Programming Scala, 3rd Edition

by Dean Wampler

May 2021

Intermediate to advanced

553 pages

13h 45m

English

O'Reilly Media, Inc.

Book available

Read now

Unlock full access

Foreword, Third EditionForeword, First and Second Edition
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
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
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
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
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
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
Using ClausesContext BoundsOther Context ParametersContext FunctionsConstraining Allowed InstancesImplicit EvidenceWorking Around Type Erasure with Using ClausesRules for Using ClausesImproving Error MessagesRecap and What’s Next
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
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

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
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
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
Linearization of a Type HierarchyInitializing Abstract FieldsOverriding Concrete FieldsAbstract Type Members and Concrete Type AliasesRecap and What’s Next
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
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
Public Visibility: The DefaultVisibility KeywordsProtected VisibilityPrivate VisibilityScoped Private and Protected VisibilityRecap and What’s Next
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
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
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
The scala.sys.process PackageFuturesRobust, Scalable Concurrency with ActorsAkka: Actors for ScalaActors: Final ThoughtsStream ProcessingRecap and What’s Next
Structural Types RevisitedA Motivating Example: ActiveRecord in Ruby on RailsDynamic Invocation with the Dynamic TraitDSL ConsiderationsRecap and What’s Next
Internal DSLsExternal DSLs with Parser CombinatorsAbout Parser CombinatorsA Payroll External DSLInternal Versus External DSLs: Final ThoughtsRecap and What’s Next
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
Recap of What We Already KnowAnnotationsUsing @main Entry PointsDesign PatternsCreational PatternsStructural PatternsBehavioral PatternsBetter Design with Design by ContractThe Parthenon ArchitectureRecap and What’s Next
Scala Compile Time ReflectionJava Runtime ReflectionScala Reflect APIType Class Derivation: Implementation DetailsScala 3 MetaprogrammingInlineMacrosStagingWrapping Up and Looking Ahead

Content preview from Programming Scala, 3rd Edition

Chapter 23. Application Design

Until now, we have mostly discussed language features. Most of the examples we’ve studied have been small, although I tried to make them realistic and useful. Actually, small is a very good thing. Drastic reduction in code size means all the problems of software development diminish in significance.

Not all applications can be small, however. This chapter considers the concerns of large, evolving APIs and applications. We’ll discuss a few Scala language and API features that we haven’t covered yet, consider a few design patterns and idioms, discuss architecture concepts, and balance object-oriented versus functional design techniques.

Recap of What We Already Know

Let’s recap a few of the concepts we’ve covered already that make small design problems easier to solve and thereby provide a stable foundation for applications.

Functional composition: Most of the book examples have been tiny in large part because we’ve used the concise, powerful combinators provided by collections and other containers. They allow us to compose logic with a minimum amount of code.
Types, especially parametric polymorphism: Types enforce constraints. Ideally, they express as much information as possible about the behavior of our programs. For example, using Option[T] can eliminate the use of nulls. Parameterized types and abstract type members are tools for abstraction and code reuse.
Mixin traits: Traits enable modularized and composable behaviors.
for comprehensions ...