Book Image

Scala Design Patterns - Second Edition

By : Ivan Nikolov
Book Image

Scala Design Patterns - Second Edition

By: Ivan Nikolov

Overview of this book

Design patterns make developers’ lives easier by helping them write great software that is easy to maintain, runs efficiently, and is valuable to the company or people concerned. You’ll learn about the various features of Scala and will be able to apply well-known, industry-proven design patterns in your work. The book starts off by focusing on some of the most interesting and latest features of Scala while using practical real-world examples. We will be learning about IDE’s and Aspect Oriented Programming. We will be looking into different components in Scala. We will also cover the popular "Gang of Four" design patterns and show you how to incorporate functional patterns effectively. The book ends with a practical example that demonstrates how the presented material can be combined in real-life applications. You’ll learn the necessary concepts to build enterprise-grade applications. By the end of this book, you’ll have enough knowledge and understanding to quickly assess problems and come up with elegant solutions.

Related Content you might be interested in

Current Title:

Small book image
Scala Design Patterns - Second Edition
Ivan Nikolov
Apr, 2018 | 396 pages
Small book image
Learn Scala Programming
Slava Schmidt
Oct, 2018 | 498 pages
Small book image
Professional Scala
Mads Hartmann | Ruslan Shevchenko
Jul, 2018 | 186 pages
Small book image
Learning Scala Programming
Vikash Sharma
Jan, 2018 | 426 pages
Table of Contents (14 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
The Design Patterns Out There and Setting Up Your Environment
The Design Patterns Out There and Setting Up Your Environment
Design patterns
Design pattern categories
Choosing a design pattern
Setting up the development environment
Summary
2
Traits and Mixin Compositions
Traits and Mixin Compositions
Traits
Mixin compositions
Multiple inheritance
Linearization
Testing traits
Traits versus classes
Summary
3
Unification
Unification
Functions and classes
Algebraic data types and class hierarchies
Modules and objects
Summary
4
Abstract and Self Types
Abstract and Self Types
Abstract types
Polymorphism
Self types
Summary
5
Aspect-Oriented Programming and Components
Aspect-Oriented Programming and Components
Aspect-oriented programming
Components in Scala
Summary
6
Creational Design Patterns
Creational Design Patterns
What are creational design patterns?
The factory method design pattern
The abstract factory
Other factory design patterns
Lazy initialization
The singleton design pattern
The builder design pattern
The prototype design pattern
Summary
7
Structural Design Patterns
Structural Design Patterns
Defining 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
Summary
8
Behavioral Design Patterns – Part One
Behavioral Design Patterns – Part One
Defining 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
Summary
9
Behavioral Design Patterns – Part Two
Behavioral Design Patterns – Part Two
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
Summary
10
Functional Design Patterns – the Deep Theory
Functional Design Patterns – the Deep Theory
Abstraction and vocabulary
Monoids
Functors
Monads
Summary
11
Applying What We Have Learned
Applying What We Have Learned
The lens design pattern
The cake design pattern
The pimp my library design pattern
The stackable traits design pattern
The type class design pattern
Lazy evaluation
Partial functions
Implicit injection
Duck typing
Memoization
Summary
12
Real-Life Applications
Real-Life Applications
Reasons to use libraries
The Scalaz library
Writing a complete application
Summary
13
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

The memento design pattern

Depending on the software we are writing, we might have a requirement to be able to restore the state of an object back to its previous state.

The purpose of the memento design pattern is to provide the ability to execute an undo action in order to restore an object to a previous state.

The original memento design pattern is implemented with the help of three main objects:

  • Originator: The object whose state we want to be able to restore
  • Caretaker: The object that triggers the changes to the originator object and uses the memento objects for rollback, if needed
  • Memento: The object that carries the actual state of the originator and can be used to restore to one of the previous states

It is important to know that the memento object can be handled only by the originator. The caretaker and all other classes can just store it and nothing else.

...
Previous Section
End of Section 4
Next Section