Scala Design Patterns

Cover
Title Page
Copyright and Credits
Packt Upsell
Contributors
Table of Contents
Preface
Chapter 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
	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
Chapter 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
			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
Chapter 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
Chapter 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 leaking functionality
	Summary
Chapter 5: 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
Chapter 6: 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
Chapter 7
: 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
Chapter 8: 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
Chapter 9: 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
Chapter 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
			A more advanced monad example
		Monad intuition
	Summary
Chapter 11: 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
Chapter 12: 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
Index