Scala编程深度解析 - Joshua D. Suereth

需积分: 9 13 浏览量更新于2024-07-23 收藏 3.77MB PDF 举报

"Manning出版的《Scala in Depth》由Joshua D. Suereth撰写，Martin Odersky作序，该书深入探讨了Scala编程语言的各个方面。" 《Scala in Depth》是一本专注于Scala编程语言的专业书籍，由知名出版机构Manning于2012年5月发行。本书由Scala社区的重要人物Joshua D. Suereth撰写，得到了Scala语言的设计者和实现者Martin Odersky的推荐，为读者提供了一次深入学习Scala的宝贵机会。书中涵盖了Scala的核心概念，包括但不限于： 1. **函数式编程**：Scala是一种多范式语言，融合了面向对象和函数式编程的特点。书中详细解释了高阶函数、闭包、柯里化、模式匹配以及不可变数据结构等函数式编程的关键概念。 2. **类型系统**：Scala有着强大的静态类型系统，支持类型推断、类型参数、隐式转换和特质（trait）。这些特性使得Scala在保持类型安全的同时，能够实现高度的灵活性和抽象。 3. **面向对象设计**：Scala中的类、对象、继承和组合被深入探讨，包括如何利用特质来实现多重继承的替代方案，以及如何通过隐式转换实现类的扩展。 4. ** Actors模型**：Scala内建对Akka框架的支持，书中详细介绍了Actors模型，这是构建并发和分布式系统的有效工具，它利用消息传递和状态隔离来管理线程安全。 5. ** Scalaz库**：作为Scala生态系统的一部分，Scalaz提供了许多高级函数式编程工具，如范畴论概念的实现，书中可能涉及了如何使用Scalaz来增强代码的表达性和可读性。 6. ** DSL设计**：Scala的语法特性使得它非常适合构建领域特定语言（DSL），书中可能会介绍如何利用Scala设计内部和外部DSL。 7. **并行与并发**：Scala提供了内置的并发工具，如 Futures 和 Promises，帮助开发者更高效地编写并行和并发程序。 8. **测试与调试**：书中还会涵盖Scala的测试框架，如ScalaTest和Specs，以及如何有效地调试Scala代码。此外，该书还可能包含了最佳实践、性能优化技巧、与其他Java和JVM技术的集成，以及针对初学者和经验丰富的开发者的实用建议。Manning出版社以其高质量的技术图书著称，此书同样遵循了严格的编辑标准，确保内容准确且易于理解。为了保护作者的知识产权，Manning出版社对复制、存储或传播该书内容有严格的版权规定。《Scala in Depth》是一本全面而深入的Scala教程，对于想要掌握Scala编程语言，或者希望提升现有技能的开发者来说，是一份不可或缺的参考资料。

xix

about the cover illustration

On the cover of Scala in Depth is a figure dressed in “An old Croatian folk costume.”

The illustration is taken from a reproduction of an album of Croatian traditional cos-

tumes from the mid-nineteenth century by Nikola Arsenovic, published by the Ethno-

graphic Museum in Split, Croatia, in 2003. The illustrations were obtained from a

helpful librarian at the Ethnographic Museum in Split, itself situated in the Roman

core of the medieval center of the town: the ruins of Emperor Diocletian’s retirement

palace from around AD 304. The book includes finely colored illustrations of figures

from different regions of Croatia, accompanied by descriptions of the costumes and

of everyday life.

While the caption for the illustration on the cover does not tell us the town or

region of origin, the blue woolen trousers and richly embroidered vest and jacket that

the figure is wearing are typical for the mountainous regions of central Croatia. Dress

codes and lifestyles have changed over the last 200 years, and the diversity by region,

so rich at the time, has faded away. It’s now hard to tell apart the inhabitants of differ-

ent continents, let alone of different hamlets or towns separated by only a few miles.

Perhaps we have traded cultural diversity for a more varied personal life—certainly for

a more varied and fast-paced technological life.

Manning celebrates the inventiveness and initiative of the computer business with

book covers based on the rich diversity of regional life of two centuries ago, brought

back to life by illustrations from old books and collections like this one.

2 CHAPTER 1 Scala— a blended language

Functional programming is programming through the definition and composition of

functions. Object-oriented programming is programming through the definition and

composition of objects. In Scala, functions are objects. Programs can be constructed

through both the definition and composition of objects or functions. This gives Scala

the ability to focus on “nouns” or “verbs” in a program, depending on what is the most

prominent.

Scala also blends expressive syntax with static typing. Mainstream statically typed

languages tend to suffer from verbose type annotations and boilerplate syntax. Scala

takes a few lessons from the ML programming language and offers static typing with a

nice expressive syntax. Code written in Scala can look as expressive as dynamically

typed languages, like Ruby, while retaining type safety.

Finally, Scala offers a lot of advanced language features that are not available in

Java. But Scala runs on the Java virtual machine (JVM) and has tight integration with

the Java language. This means that developers can make direct use of existing Java

libraries and integrate Scala into their Java applications while also gaining the addi-

tional power of Scala. This integration makes Scala a practical choice for any JVM-

based project.

Let’s take a deeper look at the blending of paradigms in Scala.

1.1 Functional programming meets object orientation

Functional programming and object-oriented programming are two different ways of

looking at a problem. Functional programming puts special emphasis on the “verbs”

of a program and ways to combine and manipulate them. Object-oriented program-

ming puts special emphasis on “nouns” and attaches verbs to them. The two

approaches are almost inverses of each other, with one being “top down” and the

other “bottom up.”

Object-oriented programming is a top-down approach to code design. It

approaches software by dividing code into nouns or objects. Each object has some

form of identity (self/this), behavior (methods), and state (members). After identify-

ing nouns and defining their behaviors, interactions between nouns are defined. The

problem with implementing interactions is that the interactions need to live inside an

object. Modern object-oriented designs tend to have service classes, which are a collec-

tion of methods that operate across several domain objects. Service classes, although

objects, usually don’t have a notion of state or behavior independent of the objects on

which they operate.

A good example is a program that implements the following story: “A cat catches a

bird and eats it.” An object-oriented programmer would look at this sentence and see

two nouns: cat and bird. The cat has two verbs associated with it: catch and eat. The

following program is a more object-oriented approach:

class Bird

class Cat {

def catch(b: Bird): Unit = ...

def eat(): Unit = ...

3Functional programming meets object orientation

}

val cat = new Cat

val bird = new Bird

cat.catch(bird)

cat.eat()

In the example, when a

Cat

catches a

Bird

, it converts the bird to a type of

Food

which it can then

eat

. The code focuses on the nouns and their actions:

Cat.eat()

Cat.catch(...)

. In functional programming, the focus is on the verbs.

Functional programming approaches software as the combination and application

of functions. It tends to decompose software into behaviors, or actions that need to be

performed, usually in a bottom-up fashion. Functions are viewed in a mathematical

sense, purely operations on their input. All variables are considered immutable. This

immutability aids concurrent programming. Functional programming attempts to

defer all side effects in a program as long as possible. Removing side effects makes rea-

soning through a program simpler, in a formal sense. It also provides much more

power in how things can be abstracted and combined.

In the story “A cat catches a bird and eats it,” a functional program would see the

two verbs catch and eat. A program would create these two functions and compose

them to create the program. The following program is a more functional approach:

trait Cat

trait Bird

trait Catch

trait FullTummy

def catch(hunter: Cat, prey: Bird): Cat with Catch

def eat(consumer: Cat with Catch): Cat with FullTummy

val story = (catch _) andThen (eat _)

story(new Cat, new Bird)

In the example, the

catch

method takes a

Cat

and a

Bird

and returns a new value of

type

Cat with Catch

. The eat method is defined as taking a

CatWithPrey

(a cat needs

something to eat) and returns a

FullCat

(because it’s no longer hungry). Functional

programming makes more use of the type system to describe what a function is doing.

The

catch

and

eat

methods use the type signatures to define the expected input and

output states of the function. The

with

keyword is used to combine a type with

another. In this example, the traits Catch and FullTummy are used to denote the

current

state

of a Cat. The methods

eat

and

catch

return new instances of Cat

attached to different state types. The

story

value is created by composing the func-

tions

catch

and

eat

. This means that the

catch

method is called and the result is fed

into the

eat

method. Finally, the

story

function is called with a

Cat

and a

Bird

and

the result is the output of the story: a full cat.

Functional programming and object orientation offer unique views of software. It’s

these differences that make them useful to each other. Object orientation can deal

with composing the nouns and functional programming can deal with composing

4 CHAPTER 1 Scala— a blended language

verbs. In the example, the functional version was built by composing a set of functions

that encompassed a story and then feeding the initial data into these functions. For the

object-oriented version, a set of objects was created and their internal state was manip-

ulated. Both approaches are useful in designing software. Object orientation can focus

on the nouns of the system and functional programming can compose the verbs.

In fact, in recent years, many Java developers have started moving toward splitting

nouns and verbs. The Enterprise JavaBeans (EJB) specification splits software into Ses-

sion beans, which tend to contain behaviors, and Entity beans, which tend to model the

nouns in the system. Stateless Session beans start looking more like collections of

functional code (although missing most of the useful features of functional code).

This push of functional style has come along much further than the EJB specifica-

tions. The Spring Application Framework promotes a functional style with its Tem-

plate classes, and the Google Collections library is very functional in design. Let’s look

at these common Java libraries and see how Scala’s blend of functional programming

with object orientation can enhance these Application Program Interfaces (APIs).

1.1.1 Discovering existing functional concepts

Many modern API designs have been incorporating functional ideas without ascribing

them to functional programming. For Java, things such as Google Collections or the

Spring Application Framework make popular functional concepts accessible to the

Java developer. Scala takes this further and embeds them into the language. To illus-

trate, you’ll do a simple translation of the methods on the popular Spring

Jdbc-

Template

class and see what it starts to look like in Scala.

public interface JdbcTemplate {

List query(PreparedStatementCreator psc,

RowMapper rowMapper)

...

}

Now for a simple translation into Scala, you’ll convert the interface into a trait having

the same method(s):

trait JdbcTemplate {

def query(psc: PreparedStatementCreator,

rowMapper: RowMapper): List[_]

}

Table 1.1 Attributes commonly ascribed to object-oriented and functional programming

Object-oriented programming Functional programming

Composition of objects (nouns) Composition of functions (verbs)

Encapsulated stateful interaction Deferred side effects

Iterative algorithms Recursive algorithms and continuations

Imperative flow Lazy evaluation

N/A Pattern matching

Query for list of objects

剩余300页未读，继续阅读

beefcow

粉丝: 0
资源: 1

Scala编程深度解析 - Joshua D. Suereth

Manning.Functional.Programming.in.Java.2017.1

Manning.Flex.Mobile.in.Action.May.2012

Manning.ASP.NET.MVC.4.in.Action.May.2012.rar

Manning.Struts.2.in.Action.May.2008

Manning.C.Sharp.in.Depth.Apr.2008

Manning.C.Sharp.in.Depth.Apr.2008.pdf

Manning.C.Sharp.in.Depth.Apr.2008-BBL

Manning.iOS.6.in.Practice.2012

Manning.C++.Concurrency.in.Action.2012

Manning.Dependency.Injection.in.NET.2012

最新资源