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

Linearization

As we already saw, traits offer a form of multiple inheritance. In such cases, the hierarchy is not necessarily linear, but forms an acyclic graph that needs to be flattened upon compilation. What linearization does is this: it specifies a single linear order for all of the ancestors of a class, including both the regular superclass chain and the parent chains of all of the traits.

We will not have to deal with linearization in traits that contain no code. However, if we use mixins, we will have to consider it. The following will be affected by linearization:

Method definitions
Variables (both mutable—var, and immutable—val)

We already saw a simple example of linearization previously. Things, however, can get much more complicated and unexpected if the rules of linearization are not clear.

Rules of inheritance hierarchies

Before looking into linearization rules, we need to be clear on some inheritance rules in Scala:

In Java, even if a class does not explicitly extend...

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