Scala Design Patterns电子书

Scala Design Patterns

Table of Contents

Scala Design Patterns

Credits

About the Author

Acknowledgments

About the Reviewer

www.PacktPub.com

Support files, eBooks, discount offers, and more

Why subscribe?

Free access for Packt account holders

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. The Design Patterns Out There and Setting Up Your Environment

Design patterns

Scala and design patterns

The need for design patterns and their benefits

Design pattern categories

Creational design patterns

The abstract factory design pattern

The factory method design pattern

The lazy initialization design pattern

The singleton design pattern

The object pool design pattern

The builder design pattern

The prototype design pattern

Structural design patterns

The adapter design pattern

The decorator design pattern

The bridge design pattern

The composite design pattern

The facade design pattern

The flyweight design pattern

The proxy design pattern

Behavioral design patterns

The value object design pattern

The null object design pattern

The strategy design pattern

The command design pattern

The chain of responsibility design pattern

The interpreter design pattern

The iterator design pattern

The mediator design pattern

The memento design pattern

The observer design pattern

The state design pattern

The template method design pattern

The visitor design pattern

Functional design patterns

Monoids

Monads

Functors

Scala-specific design patterns

The lens design pattern

The cake design pattern

Pimp my library

Stackable traits

The type class design pattern

Lazy evaluation

Partial functions

Implicit injection

Duck typing

Memoization

How to choose a design pattern

Setting up the development environment

Installing Scala

Scala IDEs

Dependency management

SBT

Maven

SBT versus Maven

Summary

2. Traits and Mixin Compositions

Traits

Traits as interfaces

Mixing in traits with variables

Traits as classes

Extending classes

Extending traits

Mixin compositions

Mixing traits in

Composing

Composing simple traits

Composing complex traits

Composing with self types

Clashing traits

Same signatures and return types traits

Same signatures and different return types traits

Same signatures and return types mixins

Same signatures and different return types mixins

Multiple inheritance

The diamond problem

The limitations

Linearization

Rules of inheritance hierarchies

Linearization rules

How linearization works

Initialization

Method overriding

Testing traits

Using a class

Mixing the trait in

Mixing into the test class

Mixing into the test cases

Running the tests

Traits versus classes

Summary

3. Unification

Functions and classes

Functions as classes

Function literals

Functions without syntactic sugar

Increased expressivity

Algebraic data types and class hierarchies

ADTs

Sum ADTs

Product ADTs

Hybrid ADTs

The unification

Pattern matching

Pattern matching with values

Pattern matching for product ADTs

Modules and objects

Using modules

Summary

4. Abstract and Self Types

Abstract types

Generics

Abstract types

Generics versus abstract types

Usage advice

Polymorphism

Subtype polymorphism

Parametric polymorphism

Ad hoc polymorphism

Adding functions for multiple types

Self types

Using self types

Requiring multiple components

Conflicting components

Self types and the cake design pattern

Self types versus inheritance

Inheritance leaks functionality

Summary

5. Aspect-Oriented Programming and Components

Aspect-oriented programming

Chapter case example

Without AOP

With AOP

Components in Scala

Scala is rich

Implementing components

Self types for components

Summary

6. Creational Design Patterns

What are creational design patterns?

The factory method design pattern

Class diagram

Code example

Scala alternatives

What is it good for?

What is it not so good for?

The abstract factory

Class diagram

Code example

Scala alternatives

What is it good for?

What is it not so good for?

Other factory design patterns

The static factory

The simple factory

Factory combinations

Lazy initialization

Class diagram

Code example

What is it good for?

What is it not so good for?

The singleton design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

The builder design pattern

Class diagram

Code example

Java-like implementation

Implementation with a case class

Using generalized type constraints

Changing the Person class

Changing the PersonBuilder class

Adding generalized type constraints to the required methods

Using the type-safe builder

Using require statements

What is it good for?

What is it not so good for?

The prototype design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

Summary

7. Structural Design Patterns

What are structural design patterns?

The adapter design pattern

Class diagram

Code example

The adapter design pattern with final classes

The adapter design pattern the Scala way

What is it good for?

What is it not so good for?

The decorator design pattern

Class diagram

Code example

The decorator design pattern the Scala way

What is it good for?

What is it not so good for?

The bridge design pattern

Class diagram

Code example

The bridge design pattern the Scala way

What is it good for?

What is it not so good for?

The composite design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

The facade design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

The flyweight design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

The proxy design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

Summary

8. Behavioral Design Patterns – Part 1

What are behavioral design patterns?

The value object design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

The null object design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

The strategy design pattern

Class diagram

Code example

The strategy design pattern the Scala way

The command design pattern

Class diagram

Code example

The command design pattern the Scala way

What is it good for?

What is it not so good for?

The chain of responsibility design pattern

Class diagram

Code example

The chain of responsibility design pattern the Scala way

What is it good for?

What is it not so good for?

The interpreter design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

Summary

9. Behavioral Design Patterns – Part 2

The iterator design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

The mediator design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

The memento design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

The observer design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

The state design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

The template method design pattern

Class diagram

Code example

What is it good for?

What is it not so good for?

The visitor design pattern

Class diagram

Code example

The visitor design pattern the Scala way

What is it good for?

What is it not so good for?

Summary

10. Functional Design Patterns – The Deep Theory

Abstraction and vocabulary

Monoids

What are monoids?

Monoids in real life

Using monoids

Monoids and foldable collections

Monoids and parallel computations

Monoids and composition

When to use monoids?

Functors

Functors in real life

Using our functors

Monads

What is a monad?

The flatMap method

The unit method

The connection between map, flatMap, and unit

The names of the methods

The monad laws

Monads in real life

Using monads

The option monad

More advanced monad example

Monad intuition

Summary

11. Functional Design Patterns – Applying What We Learned

The lens design pattern

Lens example

Without the lens design pattern

Immutable and verbose

Using mutable properties

With the lens design pattern

Minimizing the boilerplate

The cake design pattern

Dependency injection

Dependency injection libraries and Scala

Dependency injection in Scala

Writing our code

Wiring it all up

Unit testing our application

Other alternatives

Implicits

Reader monad

The pimp my library design pattern

Using the pimp my library

Pimp my library in real life

The stackable traits design pattern

Using stackable traits

The type class design pattern

Type class example

Alternatives

Lazy evaluation

Evaluating by name parameters only once

Alternative lazy evaluation

Partial functions

Partial functions are not partially applied functions

Partially defined functions

Implicit injection

Implicit conversions

Dependency injection using implicits

Testing with implicit dependency injection

Duck typing

Duck typing example

Alternatives

When to use duck typing

Memoization

Memoization example

Alternatives

Summary

12. Real-Life Applications

Why should we use libraries?

The Scalaz library

Monoids in Scalaz

Using monoids

Testing monoids

Monads in Scalaz

Using monads

Testing monads

The possibilities of Scalaz

Writing a complete application

Application specifications

Implementation

The libraries to use

Writing some code

Wiring it all up

The end result

Testing

Unit testing

Application testing

The future of our application

Summary

Index