Name: Scala Design Patterns.
Author: Ivan Nikolov
ISBN: 9781788472098

微信读书书城Scala Design Patterns.

首页我的书架登录

翻译完成

切换

Scala Design Patterns.

Ivan Nikolov

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

简介

版权

Scala Design Patterns.