9. Behavioral Design Patterns – Part 2 | Scala Design Patterns

Sign In Start Free Trial

Book Overview & Buying
Table Of Contents

Scala Design Patterns

By : Ivan Nikolov

4.2 (5)

Scala Design Patterns

4.2 (5)

By: Ivan Nikolov

Overview of this book

Scala has become increasingly popular in many different IT sectors. The language is exceptionally feature-rich which helps developers write less code and get faster results. Design patterns make developer’s 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 will learn about the various features of Scala and 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 features of Scala while using practical real-world examples. We will also cover the popular "Gang of Four" design patterns and show you how to incorporate functional patterns effectively. By the end of this book, you will have enough knowledge and understanding to quickly assess problems and come up with elegant solutions.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

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

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

Design patterns

Design pattern categories

How to choose a design pattern

Setting up the development environment

Summary

2. Traits and Mixin Compositions

2. Traits and Mixin Compositions

Traits

Mixin compositions

Multiple inheritance

Linearization

Testing traits

Traits versus classes

Summary

3. Unification

3. Unification

Functions and classes

Algebraic data types and class hierarchies

Modules and objects

Summary

4. Abstract and Self Types

4. Abstract and Self Types

Abstract types

Polymorphism

Self types

Summary

5. Aspect-Oriented Programming and Components

5. Aspect-Oriented Programming and Components

Aspect-oriented programming

Chapter case example

Components in Scala

Summary

6. Creational Design Patterns

6. 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

7. Structural Design Patterns

What are 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 1

8. Behavioral Design Patterns – Part 1

What are 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 2

9. Behavioral Design Patterns – Part 2

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

10. Functional Design Patterns – The Deep Theory

Abstraction and vocabulary

Monoids

Functors

Monads

Summary

11. Functional Design Patterns – Applying What We Learned

11. Functional Design Patterns – Applying What We 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

12. Real-Life Applications

Why should we use libraries?

The Scalaz library

Writing a complete application

Summary

Index

Index

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:

Note

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.

Class diagram

A classical example of the memento design pattern that comes to mind is text editors. We can always undo whatever...

CONTINUE READING

83

Tech Concepts

36

Programming languages

73

Tech Tools

Unlimited access to the largest independent learning library in tech of over 8,000 expert-authored tech books and videos.

Innovative learning tools, including AI book assistants, code context explainers, and text-to-speech.

50+ new titles added per month and exclusive early access to books as they are being written.

Scala Design Patterns

Search

Your notes and bookmarks