Programming Scala. 3rd Edition Dean Wampler

Spis treści książki

• 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
  • OReilly Online Learning
  • How to Contact Us
  • Acknowledgments for the Third Edition
  • Acknowledgments for the Second Edition
  • Acknowledgments for the First Edition
• 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 Whats Next
• 2. Type Less, Do More
  • New Scala 3 SyntaxOptional Braces
  • Semicolons
  • Variable Declarations
  • Ranges
  • Partial Functions
  • Method Declarations
    • Method Default and Named Parameters
    • Methods with Multiple Parameter Lists
      • A Taste of Futures
    • 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 Cant 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
  • Recap and Whats Next
• 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
  • Recap and Whats Next
• 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
  • Recap and Whats Next
• 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
  • Recap and Whats Next
• 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
  • Recap and Whats Next
• 7. Functional Programming in Scala
  • What Is Functional Programming?
    • Functions in Mathematics
    • Variables That Arent
  • Functional Programming in Scala
    • Anonymous Functions, Lambdas, and Closures
      • Methods as Functions
    • 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: Softwares Best Component Abstractions
  • What About Making Copies?
  • Recap and Whats Next
• 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
      • Throwing exceptions versus returning either values
    • Try: When There Is No Do
    • Validated from the Cats Library
  • Recap and Whats Next
• 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
      • Opaque type aliases and matchable
    • 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
  • Recap and Whats Next
• 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?
  • Recap and Whats Next
• 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
  • Recap and Whats Next
• 12. Instance Initialization and Method Resolution
  • Linearization of a Type Hierarchy
  • Initializing Abstract Fields
  • Overriding Concrete Fields
  • Abstract Type Members and Concrete Type Aliases
  • Recap and Whats Next
• 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
  • Recap and Whats Next
• 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
  • Recap and Whats Next
• 15. Visibility Rules
  • Public Visibility: The Default
  • Visibility Keywords
  • Protected Visibility
  • Private Visibility
  • Scoped Private and Protected Visibility
  • Recap and Whats Next
• 16. Scalas Type System, Part I
  • Parameterized Types
  • Abstract Type Members and Concrete Type Aliases
    • Comparing Abstract Type Members Versus Parameterized Types
  • Type Bounds
    • Upper Type Bounds
    • Lower Type Bounds
  • Context Bounds
  • View Bounds
  • Intersection and Union Types
    • Intersection Types
      • Rules for intersection types
    • Union Types
      • Rules for union types
      • Rules for union and intersection types together
  • Phantom Types
  • Structural Types
  • Refined Types
  • Existential Types (Obsolete)
  • Recap and Whats Next
• 17. Scalas 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
  • Recap and Whats Next
• 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
  • Recap and Whats Next
• 19. Tools for Concurrency
  • The scala.sys.process Package
  • Futures
  • Robust, Scalable Concurrency with Actors
    • Akka: Actors for Scala
    • Actors: Final Thoughts
  • Stream Processing
  • Recap and Whats Next
• 20. Dynamic Invocation in Scala
  • Structural Types Revisited
  • A Motivating Example: ActiveRecord in Ruby on Rails
  • Dynamic Invocation with the Dynamic Trait
  • DSL Considerations
  • Recap and Whats Next
• 21. Domain-Specific Languages in Scala
  • Internal DSLs
  • External DSLs with Parser Combinators
    • About Parser Combinators
    • A Payroll External DSL
  • Internal Versus External DSLs: Final Thoughts
  • Recap and Whats Next
• 22. Scala Tools and Libraries
  • Scala 3 Versions
  • Command-Line Interface Tools
    • Coursier
    • Managing Java JDKs with Coursier
    • The scalac Command-Line Tool
    • The scala Command-Line Tool
    • The scaladoc Command-Line Tool
    • Other Scala Command-Line Tools
  • Build Tools
  • Integration with IDEs and Text Editors
  • Using Notebook Environments with Scala
  • Testing Tools
  • Scala for Big Data: Apache Spark
  • Typelevel Libraries
  • Li Haoyi Libraries
  • Java and Scala Interoperability
    • Using Java Identifiers in Scala Code
    • Scala Identifiers in Java Code
    • Java Generics and Scala Parameterized Types
    • Conversions Between Scala and Java Collections
    • Java Lambdas Versus Scala Functions
    • Annotations for JavaBean Properties and Other Purposes
  • Recap and Whats Next
• 23. Application Design
  • Recap of What We Already Know
  • Annotations
  • Using @main Entry Points
  • Design Patterns
    • Creational Patterns
    • Structural Patterns
    • Behavioral Patterns
  • Better Design with Design by Contract
  • The Parthenon Architecture
  • Recap and Whats Next
• 24. Metaprogramming: Macros and Reflection
  • Scala Compile Time Reflection
  • Java Runtime Reflection
  • Scala Reflect API
  • Type Class Derivation: Implementation Details
  • Scala 3 Metaprogramming
    • Inline
    • Macros
    • Staging
  • Wrapping Up and Looking Ahead
• A. Significant Indentation Versus Braces Syntax
• Bibliography
• Index

pokaż cały spis treści

ukryj recenzje