Chapter 1, The Design Patterns Out There and Setting Up Your Environment, is a brief introduction to design patterns, why they exist, and their different types. This chapter also provides you with tips on how you can set up your environment in order to easily run the examples in the book.

Chapter 2, Traits and Mixin Compositions, talks about traits and mixin compositions in Scala, multiple inheritance, and the rules of linearization that the Scala programming language uses when extending multiple traits.

Chapter 3, Unification, covers the various unifications that exist in Scala, which make it as expressive as it is.

Chapter 4, Abstract and Self Types, covers the different types of polymorphism that exist in Scala that help to make generic and extendible software.

Chapter 5, Aspect-Oriented Programming and Components, shows the concept of aspect-oriented programming and how it can be applied to Scala. This chapter also explains what components are and how to build applications using multiple small and simple components.

Chapter 6, Creational Design Patterns, covers the most popular creational design patterns from the Gang of Four. All patterns are viewed from the point of view of Scala and alternatives are shown where applicable.

Chapter 7, Structural Design Patterns, goes through the most popular structural design patterns from the Gang of Four from the Scala point of view. This chapter also shows Scala alternatives where this is applicable and gives usage advice.

Chapter 8, Behavioral Design Patterns – Part 1, covers Part 1 of behavioral design patterns from the Gang of Four viewed from the Scala perspective. This chapter also provides examples and usage advice.

Chapter 9, Behavioral Design Patterns – Part 2, covers Part 2 of behavioral design patterns from the Gang of Four viewed from the Scala perspective. This chapter also provides examples and usage advice.

Chapter 10, Functional Design Patterns – The Deep Theory, delves into pure functional programming concepts such as monoids, functors, and monads. This chapter also explains these concepts in an understandable way, along with some examples.

Chapter 11, Functional Design Patterns – Applying What We Learned, presents design patterns that are specific to Scala. It is loaded with examples along with theory and usage advice.

Chapter 12, Real-Life Applications, introduces you to the Scalaz library. You will write a complete application that applies many of the concepts learned in the book, and you will finish off with a summary.

You will need to install an IDE that supports the Scala programming language (IntelliJ IDEA or Eclipse), even though a text editor also works well to read the code. You will need to have Maven and Scala (not 100% required as Maven will take care of downloading Scala for the purposes of compilation).

The examples in the book were written and tested on a Unix-based operating system; however, they should also successfully compile and run on Windows.

You are a software engineer who already has some knowledge of Scala, but wants to get more practical understanding of how to apply it in real-world application development, or you might simply want to have a useful reference to consult while designing applications. Having an understanding of the importance of using best practices and writing nice code is good; however, even if you don't, hopefully you will be convinced by the time you finish reading this book. Prior knowledge of design patterns is not required, but if you are familiar with some, this book will be useful, as we will be looking at them from the point of view of Scala.

In this book, you will find a number of text styles that distinguish between different kinds of information. Here are some examples of these styles and an explanation of their meaning.

Code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles are shown as follows: "We can include other contexts through the use of the include directive."

A block of code is set as follows:

object IOAction {
  
  def apply[T](result: => T): IOAction[T] =
    new SimpleAction[T](result)
  
  private class SimpleAction[T](result: => T) extends IOAction[T] {
    override def apply(state: State): (State, T) = 
      (state.next, result)
  }
}

When we wish to draw your attention to a particular part of a code block, the relevant lines or items are set in bold:

abstract class FileIO {
  // this makes sure nobody can create a state
  private class FileIOState(id: Int) extends State {
    override def next: State = new FileIOState(id + 1)
  }

  def run(args: Array[String]): Unit = {
    val action = runIO(args(0), args(1))
    action(new FileIOState(0))
  }

  def runIO(readPath: String, writePath: String): IOAction[_]
}

New terms and important words are shown in bold.

Feedback from our readers is always welcome. Let us know what you think about this book—what you liked or disliked. Reader feedback is important for us as it helps us develop titles that you will really get the most out of.

To send us general feedback, simply e-mail <[email protected]>, and mention the book's title in the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, see our author guide at www.packtpub.com/authors.

Now that you are the proud owner of a Packt book, we have a number of things to help you to get the most from your purchase.