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

Multiple inheritance

We inevitably had to mention multiple inheritance in the previous sections due to the fact that we can mix multiple traits and they can all have their own implementations of the methods. Multiple inheritance is not only a powerful technique, but also a dangerous one, and some languages such as Java have decided to not even allow it. As we already saw, Scala allows this, but with some limitations. In this subsection, we will present the problems of multiple inheritance and show how Scala deals with them.

The diamond problem

Multiple inheritance suffers from the diamond problem.

Let's have a look at the following diagram:

The diamond problem

Here, both B and C extend A and then D extends B and C. Some ambiguities might arise from this. Let's say that there was a method that was originally defined in A, but both B and C override it. What would happen if D calls this method? Which one will it exactly call?

All the preceding questions make things ambiguous and this could lead to mistakes...

Visually different images

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