Book Image

Scala Design Patterns

By : Ivan Nikolov
Book Image

Scala Design Patterns

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.

Related Content you might be interested in

Current Title:

Small book image
Scala Design Patterns
Ivan Nikolov
Feb, 2016 | 382 pages
No titles found
Table of Contents (20 chapters)
Scala Design Patterns
Scala Design Patterns
Credits
Credits
About the Author
About the Author
Acknowledgments
Acknowledgments
About the Reviewer
About the Reviewer
www.PacktPub.com
www.PacktPub.com
Preface
Preface
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
How to choose 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
Chapter case example
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
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
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
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
Functional Design Patterns – The Deep Theory
Abstraction and vocabulary
Monoids
Functors
Monads
Summary
11
Functional Design Patterns – Applying What We Learned
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
Real-Life Applications
Why should we use libraries?
The Scalaz library
Writing a complete application
Summary
Index
Index

The type class design pattern

A lot of times when we write software, we encounter similarities between different implementations. An important principle of good code design is to avoid repetition and it is known as do not repeat yourself (DRY). There are multiple ways that help us to avoid repetitions—inheritance, generics, and so on.

One way to make sure we do not repeat ourselves is through type classes. The purpose of type classes is to:

Note

Define some behavior in terms of operations that a type must support in order to be considered a member of the type class.

A concrete example would be Numeric. We can say that it is a type class and defines the the operations: addition, subtraction, multiplication, and so on, for the Int, Double, and such other classes. We have actually already encountered type classes earlier in this book in Chapter 4, Abstract and Self Types. Type classes are the ones that allow us to implement ad-hoc polymorphism.

Type class example

Let's see an actual example that...

Previous Section
End of Section 6
Next Section