Programming Scala, 3rd Edition / Wampler, Dean.

Format:

Book

Author/Creator:

Wampler, Dean, author.

Language:

English

Subjects (All):

Scala (Computer program language).

Physical Description:

1 online resource (550 pages)

Edition:

3rd edition

Place of Publication:

O'Reilly Media, Inc., 2021.

System Details:

text file

Summary:

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 today's highly scalable, data-centric applications that support concurrency and distribution. Despite the reinvigoration of Java and the introduction of Kotlin, 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 (FP) techniques Build killer big data and distributed apps, using Scala's functional combinators and tools including Akka and Spark Use traits for mixin composition and pattern matching for data extraction Learn the sophisticated type system that combines functional programming and object-oriented programming concepts

Contents:

Intro

Copyright

Table of Contents

Foreword

Foreword, Third Edition

Foreword, First and Second Edition

Preface

Welcome to Programming Scala, Third Edition

How to Read This Book

Welcome to Programming Scala, Second Edition

Welcome to Programming Scala, First Edition

Conventions Used in This Book

Using Code Examples

Getting the Code Examples

O'Reilly Online Learning

How to Contact Us

Acknowledgments for the Third Edition

Acknowledgments for the Second Edition

Acknowledgments for the First Edition

Chapter 1. Zero to Sixty: Introducing Scala

Why Scala?

The Appeal of Scala

Why Scala 3?

Migrating to Scala 3

Installing the Scala Tools You Need

Building the Code Examples

More Tips

Using sbt

Running the Scala Command-Line Tools Using sbt

A Taste of Scala

A Sample Application

Recap and What's Next

Chapter 2. Type Less, Do More

New Scala 3 Syntax-Optional Braces

Semicolons

Variable Declarations

Ranges

Partial Functions

Method Declarations

Method Default and Named Parameters

Methods with Multiple Parameter Lists

Nesting Method Definitions and Recursion

Inferring Type Information

Repeated Parameter Lists

Language Keywords

Literal Values

Numeric Literals

Boolean Literals

Character Literals

String Literals

Symbol Literals

Function Literals

Tuples

Option, Some, and None: Avoiding Nulls

When You Really Can't Avoid Nulls

Sealed Class Hierarchies and Enumerations

Organizing Code in Files and Namespaces

Importing Types and Their Members

Package Imports and Package Objects

Parameterized Types Versus Abstract Type Members

Chapter 3. Rounding Out the Basics

Defining Operators

Allowed Characters in Identifiers

Methods with Empty Parameter Lists.

Operator Precedence Rules

Enumerations and Algebraic Data Types

Interpolated Strings

Scala Conditional Expressions

Conditional and Comparison Operators

for Comprehensions

for Loops

Generators

Guards: Filtering Values

Yielding New Values

Expanded Scope and Value Definitions

Scala while Loops

Using try, catch, and finally Clauses

Call by Name, Call by Value

Lazy Values

Traits: Interfaces and Mixins in Scala

When new Is Optional

Chapter 4. Pattern Matching

Safer Pattern Matching with Matchable

Values, Variables, and Types in Matches

Matching on Sequences

Pattern Matching on Repeated Parameters

Matching on Tuples

Parameter Untupling

Guards in Case Clauses

Matching on Case Classes and Enums

Matching on Regular Expressions

Matching on Interpolated Strings

Sealed Hierarchies and Exhaustive Matches

Chaining Match Expressions

Pattern Matching Outside Match Expressions

Problems in Pattern Bindings

Pattern Matching as Filtering in for Comprehensions

Pattern Matching and Erasure

Extractors

unapply Method

Alternatives to Option Return Values

unapplySeq Method

Implementing unapplySeq

Chapter 5. Abstracting Over Context: Type Classes and Extension Methods

Four Changes

Extension Methods

Build Your Own String Interpolator

Type Classes

Scala 3 Type Classes

Alias Givens

Scala 2 Type Classes

Scala 3 Implicit Conversions

Type Class Derivation

Givens and Imports

Givens Scoping and Pattern Matching

Resolution Rules for Givens and Extension Methods

The Expression Problem

Chapter 6. Abstracting Over Context: Using Clauses

Using Clauses

Context Bounds

Other Context Parameters

Context Functions

Constraining Allowed Instances.

Implicit Evidence

Working Around Type Erasure with Using Clauses

Rules for Using Clauses

Improving Error Messages

Chapter 7. Functional Programming in Scala

What Is Functional Programming?

Functions in Mathematics

Variables That Aren't

Functional Programming in Scala

Anonymous Functions, Lambdas, and Closures

Purity Inside Versus Outside

Recursion

Tail Calls and Tail-Call Optimization

Partially Applied Functions Versus Partial Functions

Currying and Uncurrying Functions

Tupled and Untupled Functions

Partial Functions Versus Functions Returning Options

Functional Data Structures

Sequences

Maps

Sets

Traversing, Mapping, Filtering, Folding, and Reducing

Traversing

Mapping

Flat Mapping

Filtering

Folding and Reducing

Left Versus Right Folding

Combinators: Software's Best Component Abstractions

What About Making Copies?

Chapter 8. for Comprehensions in Depth

Recap: The Elements of for Comprehensions

for Comprehensions: Under the Hood

Translation Rules of for Comprehensions

Options and Container Types

Option as a Container?

Either: An Alternative to Option

Try: When There Is No Do

Validated from the Cats Library

Chapter 9. Object-Oriented Programming in Scala

Class and Object Basics: Review

Open Versus Closed Types

Classes Open for Extension

Overriding Methods? The Template Method Pattern

Reference Versus Value Types

Opaque Types and Value Classes

Opaque Type Aliases

Value Classes

Supertypes

Constructors in Scala

Calling Supertype Constructors

Export Clauses

Good Object-Oriented Design: A Digression

Fields in Types

The Uniform Access Principle

Unary Methods

Chapter 10. Traits.

Traits as Mixins

Stackable Traits

Union and Intersection Types

Transparent Traits

Using Commas Instead of with

Trait Parameters

Should That Type Be a Class or Trait?

Chapter 11. Variance Behavior and Equality

Parameterized Types: Variance Under Inheritance

Functions Under the Hood

Variance of Mutable Types

Improper Variance of Java Arrays

Equality of Instances

The equals Method

The == and != Methods

The eq and ne Methods

Array Equality and the sameElements Method

Equality and Inheritance

Multiversal Equality

Case Objects and hashCode

Chapter 12. Instance Initialization and Method Resolution

Linearization of a Type Hierarchy

Initializing Abstract Fields

Overriding Concrete Fields

Abstract Type Members and Concrete Type Aliases

Chapter 13. The Scala Type Hierarchy

Much Ado About Nothing (and Null)

The scala Package

Products, Case Classes, Tuples, and Functions

Tuples and the Tuple Trait

The Predef Object

Implicit Conversions

Type Definitions

Condition Checking Methods

Input and Output Methods

Miscellaneous Methods

Chapter 14. The Scala Collections Library

Different Groups of Collections

Abstractions with Multiple Implementations

The scala.collection.immutable Package

The scala.collection.mutable Package

The scala.collection Package

The scala.collection.concurrent Package

The scala.collection.convert Package

The scala.collection.generic Package

Construction of Instances

The Iterable Abstraction

Polymorphic Methods

Equality for Collections

Nonstrict Collections: Views

Chapter 15. Visibility Rules

Public Visibility: The Default

Visibility Keywords

Protected Visibility.

Private Visibility

Scoped Private and Protected Visibility

Chapter 16. Scala's Type System, Part I

Parameterized Types

Comparing Abstract Type Members Versus Parameterized Types

Type Bounds

Upper Type Bounds

Lower Type Bounds

View Bounds

Intersection and Union Types

Intersection Types

Union Types

Phantom Types

Structural Types

Refined Types

Existential Types (Obsolete)

Chapter 17. Scala's Type System, Part II

Match Types

Dependently Typed Methods

Dependent Method and Dependent Function Types

Dependent Typing

Path-Dependent Types

Using this

Using super

Stable Paths

Self-Type Declarations

Type Projections

More on Singleton Types

Self-Recursive Types: F-Bounded Polymorphism

Higher-Kinded Types

Type Lambdas

Polymorphic Functions

Type Wildcard Versus Placeholder

Chapter 18. Advanced Functional Programming

Algebraic Data Types

Sum Types Versus Product Types

Properties of Algebraic Data Types

Final Thoughts on Algebraic Data Types

Category Theory

What Is a Category?

Functor

The Monad Endofunctor

The Semigroup and Monoid Categories

Chapter 19. Tools for Concurrency

The scala.sys.process Package

Futures

Robust, Scalable Concurrency with Actors

Akka: Actors for Scala

Actors: Final Thoughts

Stream Processing

Chapter 20. Dynamic Invocation in Scala

Structural Types Revisited

A Motivating Example: ActiveRecord in Ruby on Rails

Dynamic Invocation with the Dynamic Trait

DSL Considerations

Chapter 21. Domain-Specific Languages in Scala

Internal DSLs.

External DSLs with Parser Combinators.

Notes:

Online resource; Title from title page (viewed August 25, 2021)

Description based on publisher supplied metadata and other sources.

ISBN:

1-4920-7784-4

1-4920-7786-0

1-4920-7788-7

OCLC:

1255229124