精通Scala函数式编程模式：构建优雅系统

4星 · 超过85%的资源需积分: 10 160 浏览量更新于2024-07-21 收藏 2.96MB PDF 举报

"Scala Functional Programming Patterns(PACKT,2015)"，这本书是关于使用Scala进行函数式编程的模式和最佳实践。它旨在帮助开发者理解并应用Scala的特性来构建可复用、可扩展的优雅类层次结构，通过高阶函数实现行为。书中通过具体的编程模式，展示了如何在日益复杂的软件环境中设计易于理解的系统。描述中提到，本书首先解释了模式背后的理念，使读者理解何时何地应用这些模式。书中深入讨论了尾递归的概念，这是实现无副作用解决方案的关键。接下来，作者介绍了记忆化和无穷序列，这对于按需计算非常有用。此外，还涵盖了Scala的堆叠特质和依赖注入，这两种技术可以创建松耦合的软件系统。书中的其他主题包括偏函数应用（currying）如何使代码更简洁，以及通过模式匹配进行解构，简化代码的过程。作者还通过高阶函数如管道和过滤器模式，展示了如何进行流水线转换。对于并发编程的重要性，书中也进行了探讨，并警告了传统并发代码可能遇到的问题。最后，本书转向了函数式编程带来的不同技术，展示了它们如何改变编程范式。本书对于希望理解和利用Scala的函数式编程模式解决常见编程问题的读者来说，是一份宝贵的资源。通过实例和具体的应用场景，读者将能够掌握Scala的功能特性，提升编程技能。标签：“Scala Functional Programming Patterns”表明了这本书专注于Scala语言的函数式编程模式。部分内容虽然没有提供具体的知识点，但可以看出，这本书是由Atul S. Khot所著，由PACKT Publishing出版，强调了版权信息和出版者的免责声明。此外，尽管这部分没有直接包含具体内容，但它暗示了书中可能涵盖了一系列关于Scala编程的深度讨论和实用示例。

[ v ]

Preface

This is a book on functional programming patterns using Scala. Functional

programming uses functions as basic building blocks. These are functions that don't

have any side effects. This challenges our notions about how to write programs. The

order of execution for such functions does not matter. We get to reason about them

in a referentially transparent manner. This can be a big help in proving correctness.

It feels just like a plain arithmetic problem, where (2+2)*(3+3) always equals 24. You

may evaluate the expression as 2+2 rst, or as 3+3.

I got to know about the Unix culture early in my career. The Unix philosophy relies

on pipelining small programs, each doing functionally one and only one thing. One

can connect these processing nuggets together. In addition to these hundreds of

ready-made building blocks, you could write your own too. These could be easily

connected in the pipeline. These pipes and lters were a deeply inuential concept as

a whole. When I saw Scala's combinators, options, and for comprehensions, I knew I

was looking at pipes and lters again. The nuggets in this case were Scala functions

instead of Unix processes. Understanding functional programming gives you a

new perspective on your code and programming in general. The other aspect of

pipelining is that you tend to reuse them intuitively, and you also write less. Though

you iterate lines of a text le in a Unix shell pipeline, you don't write any for loops.

These are done for you. You just specify which lines pass your criteria or how to

transform these lines or both.

Preface

[ vi ]

Scala allows you to do just that—albeit in a somewhat different form. You don't need

to write a for loop, and you keep away from loop counters. Instead, the language

invites you to write for comprehensions. Immutability is an actively advocated rule of

thumb. Another is avoiding side effects. Scala advocates both. As you probably know,

immutability paves the way for more robust concurrency. Why are these so important?

Simple, we need to reason about code. Any strategy that makes this activity controlled

and simpler is a godsend! Does going down the immutable route mean we end up

doing too much copying? How would this Copy On Write measure up against large

data structures? Scala has an answer for this in the form of structural sharing.

One-liners are very popular as they get a lot done in a line of code. Scala features

allow you to compose such one-liners. Instead of reiterating the same collection, you

can do it in one elegant expression. For example, creating an immutable class with

constructor and equality comparison dened that is bestowed with destructuring

powers is just a one-liner. We just dene a case class. There are many situations

where Scala one-liners save a lot of programmer time and result in far less code.

Combinators such as map, atMap, lter, and foreach are composed together to

express a lot of logic in a one-liner. How does it all affect a program design and

design patterns? Here are a few illustrative cases. The singleton design pattern

is used to ensure that only one instance of a class could ever exist. Null Objects

are specialized singletons that are used to avoid nulls and null checks. Scala's

Options give us a similar functionality. Scala's object keyword gives us ready-made

singletons. Singletons are specialized factories. A factory creates objects. Scala's

syntactic sugar give us a very succinct way to use the apply factory method.

The command design pattern encapsulates an object as a command. It invokes a

method on the object. Scala has parameters by name. These are not evaluated at

the call site but instead are evaluated at each use within the function. This feature

effectively replaces the command pattern with rst-class language support. The

strategy pattern encapsulates algorithms and allows us to select one at runtime.

In Java, we could express the strategy as an interface and the varying algorithms

as concrete implementations. Scala's functions are rst-class objects. You can pass

functions around as method arguments and return values. Functions can be very

effective substitutes for the strategy pattern. The ability to dene anonymous

functions is really helpful here. The Decorator pattern is needed at times. It can be

used to decorate (that is, extend) the functionality of an object without modifying

it. Some design plumbing needs to be done though. Scala's stackable traits can

express the same design very elegantly. One use of the proxy design pattern is for

implementing lazy evaluation. When some computation is expensive, we do it only

when needed.

Preface

[ vii ]

As we are very familiar with eager evaluations, we create a list in memory and think

it is fully realized. However, just like eager lists, there are lazy lists too. If we think

of a typical OR (||) conditional statement, if the left operand is true, the right is not

evaluated. This is a very powerful concept. Scala's streams provide lazy lists.

Chain of responsibility is another handy pattern that is used to decouple the sender

of a request from its receiver and allows more than one object (a chain of objects) to

handle a request. If any object in the chain is not able to handle the request, it passes

the request to its next object in the chain. Scala's partial functions t this bill nicely.

We can chain partial functions with Scala's orElse operator to realize the pattern.

When we write code, we need to handle errors. Scala's Try/Success/Failure again

allows us to write pipelines, and if any piece of the pipeline is an error, rest of the

pipeline processing is skipped.

We will look at all these concepts in greater detail. We will set up a problem, look at

the traditional Java solution, and then see how Scala changes the game.

Welcome to the Scala wonderland!

What this book covers

Chapter 1, Grokking the Functional Way, gives you an eagle's eye view of functional

programming and its advantages: succinct and readable code. Also, this chapter

compares the command pattern in Java and Scala.

Chapter 2, Singletons, Factories, and Builders, covers singletons and Null Objects as

specialized singletons. Scala Options are null objects. This also covers Scala's support

for factory method and builders.

Chapter 3, Recursion and Chasing Your Own Tail, discusses the concept of recursion

and Scala's support for it. It also looks at how recursion advocates immutability and

the concept of structural sharing.

Chapter 4, Lazy Sequences – Being Lazy, Being Good, talks about eager versus lazy

evaluation and the proxy design pattern. It also talks about Scala's streams and

innite lists.

Chapter 5, Taming Multiple Inheritance with Traits, covers Scala traits, mix-ins, and

stackable modications. It also covers dependency injection and the Cake pattern.

Chapter 6, Currying Favors with Your Code, covers lexical scope, closures, partially

applied functions, and currying. This chapter also discusses the loan pattern,

template method pattern, and another way to implement decorators.

Preface

[ viii ]

Chapter 7, Of Visitors and Chains of Responsibilities, covers the Visitor pattern and

its application. The other topics that are discussed are Scala's pattern matching

capabilities and the chain of responsibility pattern. We will also learn Scala

implementation using orElse and the collect idiom.

Chapter 8, Traversals – Mapping/Filtering/Folding/Reducing, covers iterators and

functional iteration using map, lter, fold, and reduce. This chapter introduces

Monads and explains ReduceLeft and ReduceRight.

Chapter 9, Higher Order Functions, discusses the strategy pattern and Scala version

using higher order functions. It covers map as a functor, atMap as a Monad, and

foldLeft as Monoids. Here, you will also learn how to iterate lazy collections.

Chapter 10, Actors and Message Passing, showcases a case study to recursively grep a

directory for les that contain matching text. It also covers the producer consumer

pattern and the Master Slave pattern. It explains the concept of poison pills, event-

driven programming, immutability, and concurrency. It also talks about Akka and

Actors and how to reimplement recursive grep using Actors.

Chapter 11, It's a Paradigm Shift, teaches you how to sort in Scala and the

Schwarzian transform implemented in Scala. It discusses functional error handling

with Try/Success/Failure. And talks about Java Threads versus Scala's Futures.

Scala's Parser Combinators are also discussed here.

What you need for this book

You would need Scala installed—a version greater than or equal to 2.11. I refer to

pipelining a lot, so it would be pretty helpful if you are trying out the examples on

Linux or Mac. You can use cygwin too if it is a Windows box you are running.

Version 0.13 of the sbt tool (

http://www.scala-sbt.org/) will also be needed.

A typical Java dev environment is assumed too. The examples are tested with Maven

version 3 and JDK 8.

Who this book is for

We assume that you have written Java code for a while. You also should have a

basic knowledge of Scala. A knowledge of Java and Scala fundamentals is assumed.

Familiarity with basic data structures such as binary trees and linked lists is assumed.

剩余297页未读，继续阅读

vanridin

粉丝: 108
资源: 1187

精通Scala函数式编程模式：构建优雅系统

Scala Functional Programming Patterns 无水印pdf

Scala Functional Programming Patterns

Functional Programming Patterns in Scala and Clojure

Functional Programming Patterns in Scala and Clojure epub

Functional Programming Patterns in Scala and Clojure 无水印pdf

[Pragmatic Bookshelf] Functional Programming Patterns in Scala and Clojure

Functional Programming Patterns in Scala and Clojure(Pragmatic,2013)

func-architecture-v2:“ Functional Programming Patterns v2（适用于实用的程序员）”的支持代码

Scala-Programming-Projects:Packt发布的Scala编程项目

Learning Scala Practical Functional Programming for the JVM

最新资源