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

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
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
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
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
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
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
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
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
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

Interfaces in Java 8Traits as MixinsStackable TraitsConstructing TraitsClass or Trait?Recap and What’s Next
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
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
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
Public Visibility: The DefaultVisibility KeywordsPublic VisibilityProtected VisibilityPrivate VisibilityScoped Private and Protected VisibilityFinal Thoughts on VisibilityRecap and What’s Next
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
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
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
The scala.sys.process PackageFuturesAsyncRobust, Scalable Concurrency with ActorsAkka: Actors for ScalaActors: Final ThoughtsPickling and SporesReactive ProgrammingRecap and What’s Next
Big Data: A Brief HistoryImproving MapReduce with ScalaMoving Beyond MapReduceCategories for MathematicsA List of Scala-Based Data ToolsRecap and What’s Next
A Motivating Example: ActiveRecord in Ruby on RailsDynamic Invocation in Scala with the Dynamic TraitDSL ConsiderationsRecap and What’s Next
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
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
Using Java Names in Scala CodeJava and Scala GenericsJavaBean PropertiesAnyVal Types and Java PrimitivesScala Names in Java CodeRecap and What’s Next
Recap of What We Already KnowAnnotationsTraits as ModulesDesign PatternsCreational PatternsStructural PatternsBehavioral PatternsBetter Design with Design by ContractThe Parthenon ArchitectureRecap and What’s Next
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

Overview

Get up to speed on Scala, the JVM language that offers all the benefits of a modern object model, functional programming, 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, and explains why Scala is ideal for today's highly scalable, data-centric applications that support concurrency and distribution. This second edition covers recent language features, with new chapters on pattern matching, comprehensions, and advanced functional programming.