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

Preface

Programming Scala introduces an exciting and powerful language that offers all the benefits of a modern object-oriented programming (OOP) model, functional programming (FP), and an advanced type system. Originally targeted for the Java Virtual Machine (JVM), it now also targets JavaScript and native execution as well. 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 run at any scale.

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

Welcome to Programming Scala, Third Edition

Dean Wampler, April 2021

Programming Scala, second edition was published six years ago, in the fall of 2014. At that time, interest in Scala was surging, driven by two factors.

First, alternative languages for the JVM instead of Java were very appealing. Java’s evolution was slow at the time, frustrating developers who wanted improvements like more concise syntax for some constructs and features they saw in other languages, like FP.

Second, big data was a hot sector of the software industry, and some of the most popular tools in that sector, especially Apache Spark and Apache Kafka, were written in Scala and offered concise and elegant Scala APIs.

A lot has changed in six years. Oracle deserves a lot of credit for reinvigorating Java after acquiring it through the purchase of Sun Microsystems. The pace of innovation ...