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

Abstract types

One of the most common ways to parameterize classes is by using values. This is quite simple, and it is achieved by passing different values for the constructor parameters of a class. In the following example, we can pass different values for the name parameter of the Person class, and this is how we create different instances:

case class Person(name: String)

This way we can create different instances and distinguish them, but this is neither interesting nor rocket science. Going further, we will focus on some more interesting parametrizations that will help us make our code better.

Generics

Generics are another way of parameterizing classes. They are useful when we write a functionality whose application is the same throughout various types, and we can simply defer choosing a concrete type until later. One example every developer should be familiar with is collection classes. List, for example, can store any type of data, and we can have lists of integers, doubles, strings...

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