Scala Design Patterns.电子书

Title Page

Copyright and Credits

Scala Design Patterns Second Edition

Packt Upsell

Why subscribe?

PacktPub.com

Contributors

About the author

About the reviewer

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Conventions used

Get in touch

Reviews

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

Choosing a design pattern

Setting up the development environment

Installing Scala

Tips for installing Scala manually

Tips for installing Scala using SBT

Scala IDEs

Dependency management

SBT

Maven

SBT versus Maven

Summary

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

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

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

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

Summary

Aspect-Oriented Programming and Components

Aspect-oriented programming

Understanding application efficiency

Timing our application without AOP

Timing our application with AOP

Components in Scala

Using Scala's expressive power to build components

Implementing components

Self types for components

Summary

Creational Design Patterns

What are creational design patterns?

The factory method design pattern

An example class diagram

A code example

Scala alternatives

What it is good for?

What it is not so good for?

The abstract factory

An example class diagram

A code example

Scala alternatives

What it is good for?

What it is not so good for?

Other factory design patterns

The static factory

The simple factory

Factory combinations

Lazy initialization

An example class diagram

A code example

What it is good for?

What it is not so good for?

The singleton design pattern

An example class diagram

A code example

What it is good for?

What it is not so good for?

The builder design pattern

An example class diagram

A code example

A Java-like implementation

Implementation with a case class

Using generalized type constraints

Changing the Person class

Adding generalized type constraints to the required methods

Using the type-safe builder

Using require statements

What it is good for?

What it is not so good for?

The prototype design pattern

An example class diagram

A code example

What it is good for?

What it is not so good for?

Summary

Structural Design Patterns

Defining structural design patterns

The adapter design pattern

Example class diagram

Code example

The adapter design pattern with final classes

The adapter design pattern the Scala way

What it is good for

What it is not so good for

The decorator design pattern

Example class diagram

Code example

The decorator design pattern the Scala way

What it is good for

What it is not so good for

The bridge design pattern

Example class diagram

Code example

The bridge design pattern the Scala way

What it is good for

What it is not so good for

The composite design pattern

Example class diagram

Code example

What it is good for

What it is not so good for

The facade design pattern

Example class diagram

Code example

What it is good for

What it is not so good for

The flyweight design pattern

Example class diagram

Code example

What it is good for

What it is not so good for

The proxy design pattern

Example class diagram

Code example

What it is good for

What it is not so good for

Summary

Behavioral Design Patterns – Part One

Defining behavioral design patterns

The value object design pattern

An example class diagram

A code example

Alternative implementation

What it is good for

What it is not so good for

The null object design pattern

An example class diagram

A code example

What it is good for

What it is not so good for

The strategy design pattern

An example class diagram

A code example

The strategy design pattern the Scala way

What it is good for

What it is not so good for

The command design pattern

An example class diagram

A code example

The command design pattern the Scala way

What it is good for

What it is not so good for

The chain of responsibility design pattern

An example class diagram

A code example

The chain of responsibility design pattern the Scala way

What it is good for

What it is not so good for

The interpreter design pattern

An example class diagram

A code example

What it is good for

What it is not so good for

Summary

Behavioral Design Patterns – Part Two

The iterator design pattern

Example class diagram

Code example

What it is good for

What it is not so good for

The mediator design pattern

Example class diagram

Code example

What it is good for

What it is not so good for

The memento design pattern

Example class diagram

Code example

What it is good for

What it is not so good for

The observer design pattern

Example class diagram

Code example

What it is good for

What it is not so good for

The state design pattern

Example class diagram

Code example

What it is good for

What it is not so good for

The template method design pattern

Example class diagram

Code example

What it is good for

What it is not so good for

The visitor design pattern

Example class diagram

Code example

The visitor design pattern the Scala way

What it is good for

What it is not so good for

Summary

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

A more advanced monad example

Monad intuition

Summary

Applying What We Have 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 dependency injection alternatives

Implicits for dependency injection

Reader monad for dependency injection

The pimp my library design pattern

Using 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

Type class design pattern 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

Duck typing alternatives

When to use duck typing

Memoization

Memoization example

Memoization alternatives

Summary

Real-Life Applications

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

Reading the application configuration

Reading the scheduler configuration

Scheduling tasks

Accessing a database

Executing console commands

Writing some code

Wiring it all up

The end result

Testing our application

Unit testing

Application testing

The future of our application

Summary

Other Books You May Enjoy

Leave a review - let other readers know what you think