book

Scala Design Patterns

Name: Scala Design Patterns
Author: Ivan Nikolov
ISBN: 9781785882500

by Ivan Nikolov

February 2016

Intermediate to advanced

382 pages

8h 1m

English

Packt Publishing

Read now

Unlock full access

Scala Design Patterns
Table of Contents
Scala Design Patterns
Credits
About the Author
Acknowledgments
About the Reviewer
www.PacktPub.com
Support files, eBooks, discount offers, and moreWhy subscribe?Free access for Packt account holders
Preface
What this book covers
What you need for this book

Who this book is for
Conventions
Reader feedback
Customer support
Downloading the example codeErrataPiracyQuestions
1. The Design Patterns Out There and Setting Up Your Environment
Design patternsScala and design patternsThe need for design patterns and their benefits
Design pattern categories
Creational design patternsThe abstract factory design patternThe factory method design patternThe lazy initialization design patternThe singleton design patternThe object pool design patternThe builder design patternThe prototype design patternStructural design patternsThe adapter design patternThe decorator design patternThe bridge design patternThe composite design patternThe facade design patternThe flyweight design patternThe proxy design patternBehavioral design patternsThe value object design patternThe null object design patternThe strategy design patternThe command design patternThe chain of responsibility design patternThe interpreter design patternThe iterator design patternThe mediator design patternThe memento design patternThe observer design patternThe state design patternThe template method design patternThe visitor design patternFunctional design patternsMonoidsMonadsFunctorsScala-specific design patternsThe lens design patternThe cake design patternPimp my libraryStackable traitsThe type class design patternLazy evaluationPartial functionsImplicit injectionDuck typingMemoization
How to choose a design pattern
Setting up the development environment
Installing ScalaScala IDEsDependency managementSBTMavenSBT versus Maven
Summary
2. Traits and Mixin Compositions
TraitsTraits as interfacesMixing in traits with variablesTraits as classesExtending classesExtending traits
Mixin compositions
Mixing traits inComposingComposing simple traitsComposing complex traitsComposing with self typesClashing traitsSame signatures and return types traitsSame signatures and different return types traitsSame signatures and return types mixinsSame signatures and different return types mixins
Multiple inheritance
The diamond problemThe limitations
Linearization
Rules of inheritance hierarchiesLinearization rulesHow linearization worksInitializationMethod overriding
Testing traits
Using a classMixing the trait inMixing into the test classMixing into the test casesRunning the tests
Traits versus classes
Summary
3. Unification
Functions and classesFunctions as classesFunction literalsFunctions without syntactic sugarIncreased expressivity
Algebraic data types and class hierarchies
ADTsSum ADTsProduct ADTsHybrid ADTsThe unificationPattern matchingPattern matching with valuesPattern matching for product ADTs
Modules and objects
Using modules
Summary
4. Abstract and Self Types
Abstract typesGenericsAbstract typesGenerics versus abstract typesUsage advice
Polymorphism
Subtype polymorphismParametric polymorphismAd hoc polymorphismAdding functions for multiple types
Self types
Using self typesRequiring multiple componentsConflicting componentsSelf types and the cake design patternSelf types versus inheritanceInheritance leaks functionality
Summary
5. Aspect-Oriented Programming and Components
Aspect-oriented programming
Chapter case example
Without AOPWith AOP
Components in Scala
Scala is richImplementing componentsSelf types for components
Summary
6. Creational Design Patterns
What are creational design patterns?
The factory method design pattern
Class diagramCode exampleScala alternativesWhat is it good for?What is it not so good for?
The abstract factory
Class diagramCode exampleScala alternativesWhat is it good for?What is it not so good for?
Other factory design patterns
The static factoryThe simple factoryFactory combinations
Lazy initialization
Class diagramCode exampleWhat is it good for?What is it not so good for?
The singleton design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
The builder design pattern
Class diagramCode exampleJava-like implementationImplementation with a case classUsing generalized type constraintsChanging the Person classChanging the PersonBuilder classAdding generalized type constraints to the required methodsUsing the type-safe builderUsing require statementsWhat is it good for?What is it not so good for?
The prototype design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
Summary
7. Structural Design Patterns
What are structural design patterns?
The adapter design pattern
Class diagramCode exampleThe adapter design pattern with final classesThe adapter design pattern the Scala wayWhat is it good for?What is it not so good for?
The decorator design pattern
Class diagramCode exampleThe decorator design pattern the Scala wayWhat is it good for?What is it not so good for?
The bridge design pattern
Class diagramCode exampleThe bridge design pattern the Scala wayWhat is it good for?What is it not so good for?
The composite design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
The facade design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
The flyweight design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
The proxy design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
Summary
8. Behavioral Design Patterns – Part 1
What are behavioral design patterns?
The value object design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
The null object design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
The strategy design pattern
Class diagramCode exampleThe strategy design pattern the Scala way
The command design pattern
Class diagramCode exampleThe command design pattern the Scala wayWhat is it good for?What is it not so good for?
The chain of responsibility design pattern
Class diagramCode exampleThe chain of responsibility design pattern the Scala wayWhat is it good for?What is it not so good for?
The interpreter design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
Summary
9. Behavioral Design Patterns – Part 2
The iterator design patternClass diagramCode exampleWhat is it good for?What is it not so good for?
The mediator design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
The memento design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
The observer design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
The state design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
The template method design pattern
Class diagramCode exampleWhat is it good for?What is it not so good for?
The visitor design pattern
Class diagramCode exampleThe visitor design pattern the Scala wayWhat is it good for?What is it not so good for?
Summary
10. Functional Design Patterns – The Deep Theory
Abstraction and vocabulary
Monoids
What are monoids?Monoids in real lifeUsing monoidsMonoids and foldable collectionsMonoids and parallel computationsMonoids and compositionWhen to use monoids?
Functors
Functors in real lifeUsing our functors
Monads
What is a monad?The flatMap methodThe unit methodThe connection between map, flatMap, and unitThe names of the methodsThe monad lawsMonads in real lifeUsing monadsThe option monadMore advanced monad exampleMonad intuition
Summary
11. Functional Design Patterns – Applying What We Learned
The lens design patternLens exampleWithout the lens design patternImmutable and verboseUsing mutable propertiesWith the lens design patternMinimizing the boilerplate
The cake design pattern
Dependency injectionDependency injection libraries and ScalaDependency injection in ScalaWriting our codeWiring it all upUnit testing our applicationOther alternativesImplicitsReader monad
The pimp my library design pattern
Using the pimp my libraryPimp my library in real life
The stackable traits design pattern
Using stackable traits
The type class design pattern
Type class exampleAlternatives
Lazy evaluation
Evaluating by name parameters only onceAlternative lazy evaluation
Partial functions
Partial functions are not partially applied functionsPartially defined functions
Implicit injection
Implicit conversionsDependency injection using implicitsTesting with implicit dependency injection
Duck typing
Duck typing exampleAlternativesWhen to use duck typing
Memoization
Memoization exampleAlternatives
Summary
12. Real-Life Applications
Why should we use libraries?
The Scalaz library
Monoids in ScalazUsing monoidsTesting monoidsMonads in ScalazUsing monadsTesting monadsThe possibilities of Scalaz
Writing a complete application
Application specificationsImplementationThe libraries to useWriting some codeWiring it all upThe end resultTestingUnit testingApplication testingThe future of our application
Summary
Index

Content preview from Scala Design Patterns

The interpreter design pattern

In modern programming, we sometimes have to deal with problems from well-understood and well-defined domains. In some cases, it makes sense to represent the domain with a language, which could then make it easy to solve problems using an interpreter. This is exactly what the interpreter design pattern is useful for:

Note

It specifies how to evaluate sentences in a language by representing it using classes and building syntax trees to evaluate the language expressions.

The interpreter design pattern makes use of the composite design pattern as well. Some common uses of interpreters are for language parsing, protocols, and so on.

Class diagram

Creating a language and grammar is a complicated task and before getting into ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781785882500

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design