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 22. Scala Tools and Libraries

This chapter fills in some details about the Scala command-line tools, build tool options, IDE and text editor integration, and a look at some popular third-party libraries for Scala. Finally, this chapter explores mixing Java and Scala code.

Libraries and tools change quickly. I will avoid some details that are likely to change over time, focusing instead of suggestions for finding the best options for your needs, with some current examples. For the latest library options, search the Scala Library Index.

Scala 3 Versions

To better support migration of code bases from Scala 2 to 3, Scala 3 introduces a language version construct that allows the user to specify which version should be used, either with a command-line option or an import statement.

Here is the currently defined list of versions, adapted from the documentation on language versions:

Version 3.0: The current default version. Some Scala 2 idioms are deprecated but still supported.
Version 3.0-migration: Identical to 3.0 but with a Scala 2 compatibility mode enabled that helps migration of Scala 2.13 sources over to Scala 3. In particular:

Flags some Scala 2 constructs that are disallowed in Scala 3 as migration warnings instead of hard errors.
Changes some rules to be more lenient and backward compatible with Scala 2.13.
Gives some additional warnings where the semantics have changed between Scala 2.13 and 3.0.
Offers code rewrites from Scala 2.13 to 3.0, when used ...