函数式思维：探索编程新视角

Functional

Thinking

需积分: 9 85 浏览量更新于2024-07-20 收藏 7.61MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

“Functional Thinking”是 Neal Ford 所著的一本书，专注于探讨功能性思维在软件开发中的应用。这本书由 O'Reilly Media 出版，并强调了将函数式编程思想融入到日常编程实践中的重要性。在《Functional Thinking》中，作者 Neal Ford 提倡了一种全新的编程思维方式，即功能性思维。功能性思维是一种编程范式，它源于数学，强调程序作为计算的纯函数，即程序的输出只依赖于输入，而不受任何外部状态的影响。这种思维方式鼓励开发者减少对状态的依赖，提高代码的可预测性和可测试性。书的内容可能涵盖了以下知识点： 1. **函数式编程基础**：解释函数式编程语言的核心概念，如高阶函数、纯函数、不可变数据和递归。这些概念帮助开发者理解如何用函数而不是过程来构建软件。 2. **函数组合**：讨论如何通过组合小的、简单的函数来创建更复杂的逻辑，以实现模块化和代码重用。 3. **数据结构与模式**：介绍函数式编程中常见的数据结构（如列表、树和图）以及如何使用它们。还会探讨通用的处理模式，如映射、过滤和折叠。 4. **函数式编程语言**：可能包括对 Lisp、Haskell、Scala、Clojure 等函数式编程语言的介绍，解释它们如何支持和鼓励功能性思维。 5. **并行与并发**：由于函数式编程中的不可变数据和无副作用，它天然适合并行和并发编程。书中可能深入讨论了如何利用这些特性来提升软件性能。 6. **状态管理和副作用**：解释如何在函数式编程中管理状态，以及如何通过 monads 或其他机制控制副作用。 7. **面向对象与函数式编程的融合**：讨论如何在传统的面向对象环境中引入函数式编程概念，以实现两者的协同工作。 8. **测试和调试**：函数式编程的纯函数性质使得测试变得更简单，书中可能会讲述如何有效地测试函数式代码。 9. **案例研究**：通过实际的项目或代码示例，展示如何将功能性思维应用于解决现实问题。 10. **最佳实践和技巧**：提供在实际工作中采用函数式编程的一些最佳实践，帮助读者更好地将理论应用到实践中。《Functional Thinking》旨在帮助读者理解和掌握功能性思维，从而改进他们的编程实践，提升代码质量和开发效率。这本书对于想要了解和应用函数式编程的开发者来说是一份宝贵的资源。

资源详情

资源推荐

Shifting Paradigms

Computer science often advances in fits and starts, with good ideas appearing decades

before they suddenly become part of the mainstream. For example, Simula 67, created

in 1967, is the first object-oriented language, yet object orientation didn’t really become

mainstream until after the popularization of C++, which first appeared in 1983. Often,

good ideas await foundation technologies to catch up. In its early years, Java was regu‐

larly considered too slow and expansive in memory usage for high-performance appli‐

cations, but shifts in the hardware market made it an attractive choice.

Functional programming follows the same conceptual trajectory as object orientation:

developed in academia over the last few decades, it has slowly crept into all modern

programming languages. Yet just adding new syntax to a language doesn’t inform de‐

velopers of the best way to leverage this new way of thinking.

I start with a contrast between the traditional programming style (imperative loops)

and a more functional way of solving the same problem. For the problem to solve, I dip

into a famous event in computer science history, a challenge issued from Jon Bentley,

the writer of a regular column in Communications of the ACM called “Programming

Pearls,” to Donald Knuth, an early computer science pioneer. The challenge is common

to anyone who has written text-manipulation code: read a file of text, determine the most

frequently used words, and print out a sorted list of those words along with their fre‐

quencies. Just tackling the word-frequency portion, I write a solution in “traditional”

Java, shown in Example 1-1.

Example 1-1. Word frequencies in Java

public class Words {

private Set<String> NON_WORDS = new HashSet<String>() {{

add("the"); add("and"); add("of"); add("to"); add("a");

add("i"); add("it"); add("in"); add("or"); add("is");

add("d"); add("s"); add("as"); add("so"); add("but");

add("be"); }};

public Map wordFreq(String words) {

TreeMap<String, Integer> wordMap = new TreeMap<String, Integer>();

Matcher m = Pattern.compile("\\w+").matcher(words);

while (m.find()) {

String word = m.group().toLowerCase();

if (! NON_WORDS.contains(word)) {

if (wordMap.get(word) == null) {

wordMap.put(word, 1);

}

else {

wordMap.put(word, wordMap.get(word) + 1);

}

return wordMap;

2 | Chapter 1: Why

}

In Example 1-1, I create a set of nonwords (articles and other “glue” words), then create

the wordFreq() method. In it, I build a Map to hold the key/value pairs, then create a

regular expression to allow me to determine words. The bulk of this listing iterates over

the found words, ensuring that the actual word is either added the first time to the map

or its occurrence is incremented. This style of coding is quite common in languages that

encourage you to work through collections (such as regular expression matches)

piecemeal.

Consider the updated version that takes advantage of the Stream API and the support

for higher-order functions via lambda blocks in Java 8 (all discussed in more detail later),

shown in Example 1-2.

Example 1-2. Word frequency in Java 8

private List<String> regexToList(String words, String regex) {

List wordList = new ArrayList<>();

Matcher m = Pattern.compile(regex).matcher(words);

while (m.find())

wordList.add(m.group());

return wordList;

}

public Map wordFreq(String words) {

TreeMap<String, Integer> wordMap = new TreeMap<>();

regexToList(words, "\\w+").stream()

.map(w -> w.toLowerCase())

.filter(w -> !NON_WORDS.contains(w))

.forEach(w -> wordMap.put(w, wordMap.getOrDefault(w, 0) + 1));

return wordMap;

}

In Example 1-2, I convert the results of the regular expression match to a stream, which

allows me to perform discrete operations: make all the entries lowercase, filter out the

nonwords, and count the frequencies of the remaining words. By converting the iterator

returned via find() to a stream in the regexToList() method, I can perform the re‐

quired operations one after the other, in the same way that I think about the problem.

Although I could do that in the imperative version in Example 1-1 by looping over the

collection three times (once to make each word lowercase, once to filter nonwords, and

once to count occurrences), I know not to do that because it would be terribly inefficient.

By performing all three operations within the iterator block in Example 1-1, I’m trading

clarity for performance. Although this is a common trade-off, it’s one I’d rather not make.

In his “Simple Made Easy” keynote at the Strange Loop conference, Rich Hickey, the

creator of Clojure, reintroduced an arcane word, complect: to join by weaving or twining

together; to interweave. Imperative programming often forces you to complect your

Shifting Paradigms | 3

tasks so that you can fit them all within a single loop, for efficiency. Functional pro‐

gramming via higher-order functions such as map() and filter() allows you to elevate

your level of abstraction, seeing problems with better clarity. I show many examples of

functional thinking as a powerful antidote to incidental complecting.

Aligning with Language Trends

If you look at the changes coming to all major languages, they all add functional ex‐

tensions. Groovy has been adding functional capabilities for a while, including advanced

features such as memoization (the ability for the runtime to cache function return values

automatically). Even Java itself will finally grow more functional extensions, as lambda

blocks (i.e., higher-order functions) finally appear in Java 8, and arguably the most

widely used language, JavaScript, has numerous functional features. Even the venerable

C++ added lambda blocks in the language’s 2011 standard, and has generally shown

more functional programming interest, including intriguing libraries such as the

Boost.Phoenix library.

Learning these paradigms now allows you to utilize the features as soon as they appear,

either in your use of a new language such as Clojure or in the language you use every

day. In Chapter 2, I cover how to shift your thinking to take advantage of these advanced

facilities.

Ceding Control to the Language/Runtime

During the short history of computer science, the mainstream of technology sometimes

spawns branches, either practical or academic. For example, in the 1990s, the move to

personal computers saw an explosion in popularity of fourth-generation languages

(4GL) such as dBASE, Clipper, FoxPro, Paradox, and a host of others. One of the selling

points of these languages was a higher-level abstraction than a 3GL like C or Pascal. In

other words, you could issue a single command in a 4GL that would take many com‐

mands in a 3GL because the 4GL already had more “prebaked” context. These languages

were already equipped to read popular database formats from disk rather than force

customized implementations.

Functional programming is a similar offshoot from academia, where computer scien‐

tists wanted to find ways of expressing new ideas and paradigms. Every so often, a branch

will rejoin the mainstream, which is what is happening to functional programming now.

Functional languages are sprouting not just on the Java Virtual Machine (JVM), where

the two most interesting new languages are Scala and Clojure, but on the .NET platform

as well, which includes F# as a first-class citizen. Why this embrace of functional pro‐

gramming by all the platforms?

Back in the early 1980s, when I was in university, we used a development environment

called Pecan Pascal, whose unique feature was the ability to run the same Pascal code

4 | Chapter 1: Why

on either the Apple ][ or IBM PC. The Pecan engineers achieved this feat by using

something mysterious called “bytecode.” When the developer compiled his code, he

compiled it to this “bytecode,” which ran on a “virtual machine,” written natively for

each of the two platforms. And it was a hideous experience. The resulting code was

achingly slow even for simple class assignments. The hardware at the time just wasn’t

up to the challenge.

Of course, we all recognize this architecture. A decade after Pecan Pascal, Sun released

Java using the same techniques, straining but succeeding in mid-1990s hardware envi‐

ronments. It also added other developer-friendly features, such as automatic garbage

collection. I never want to code in a non-garbage-collected language again. Been there,

done that, got the T-shirt, and don’t want to go back, because I’d rather spend my time

at a higher level of abstraction, thinking about ways to solve complex business scenarios,

not complicated plumbing problems. I rejoice in the fact that Java reduces the pain of

explicit memory management, and I try to find that same level of convenience in other

places.

Life’s too short for malloc.

Over time, developers cede more control over tedious tasks to our languages and run‐

times. I don’t lament the lack of direct memory control for the types of applications I

write, and ignoring that allows me to focus on more important problems. Java eased

our interaction with memory management; functional programming languages allow

us to replace other core building blocks with higher-order abstractions.

Examples of replacing detailed implementations with simpler ones relying on the run‐

time to handle mundane details abound in this book.

Concision

Michael Feathers, author of Working with Legacy Code, captured a key difference be‐

tween functional and object-oriented abstractions in 140 lowly characters on Twitter:

OO makes code understandable by encapsulating moving parts. FP makes code under‐

standable by minimizing moving parts.

— Michael Feathers

Think about the things you know about object-oriented programming (OOP) con‐

structs: encapsulation, scoping, visibility, and other mechanisms exist to exert fine-

grained control over who can see and change state. More complications pile up when

you deal with state plus threading. These mechanisms are what Feathers referred to as

Concision | 5

“moving parts.” Rather than build mechanisms to control mutable state, most functional

languages try to remove mutable state, a “moving part.” The theory follows that if the

language exposes fewer potentially error-prone features, it is less likely for developers

to make errors. I will show numerous examples throughout of functional programming

eliminating variables, abstractions, and other moving parts.

In object-oriented imperative programming languages, the units of reuse are classes

and the messages they communicate with, captured in a class diagram. The seminal

work in that space, Design Patterns: Elements of Reusable Object-Oriented Software (by

Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides), includes at least one

class diagram with each pattern. In the OOP world, developers are encouraged to create

unique data structures, with specific operations attached in the form of methods. Func‐

tional programming languages don’t try to achieve reuse in quite the same way. In

functional programming languages, the preference is for a few key data structures (such

as list, set, and map) with highly optimized operations on those data structures. To

utilize this machinery, developers pass data structures plus higher-order functions to

plug into the machinery, customizing it for a particular use.

Consider a simplified portion of the code from Example 1-2:

regexToList(words, "\\b\\w+\\b").stream()

.filter(w -> !NON_WORDS.contains(w))

To retrieve a subset of a list, call the filter() method, passing the list as a stream of

values and a higher-order function specifying the filter criteria (in this case, the syn‐

tactically sugared (w → !NON_WORDS.contains(w))). The machinery applies the filter

criteria in an efficient way, returning the filtered list.

Encapsulation at the function level allows reuse at a more granular, fundamental level

than building new class structures for every problem. Dozens of XML libraries exist in

the Java world, each with its own internal data structures. One advantage of leveraging

higher-level abstractions is already appearing in the Clojure space. Recent clever inno‐

vations in Clojure’s libraries have managed to rewrite the map function to be automat‐

ically parallelizable, meaning that all map operations get a performance boost without

developer intervention.

Functional programmers prefer a few core data structures, building optimized machi‐

nery to understand them. Object-oriented programmers tend to create new data struc‐

tures and attendant operations constantly—building new classes and messages between

them is the predominant object oriented paradigm. Encapsulating all data structures

within classes discourages reuse at the method level, preferring larger framework-style

reuse. Functional programming constructs make it easier to reuse code at a more atomic

level.

Consider the indexOfAny() method, from the popular Java framework Apache Com‐

mons, which provides a slew of helpers for Java, in Example 1-3.

6 | Chapter 1: Why

剩余178页未读，继续阅读

libingchen

粉丝: 29
资源: 263

函数式思维：探索编程新视角

Functional Programming pdf 2018

Functional Thinking.pdf

Functional

Becoming Functional

java函数式编程书籍

介绍一下 @FunctionalInterface

IBM Rational Functional Tester下载

@FunctionalInterface 应用场景

torch.nn.functional

Java @FunctionalInterface注解

No module named 'functional'

UserWarning: The torchvision.transforms.functional_tensor module is deprecated in 0.15 and will be **removed in 0.17**. Please don't rely on it. You probably just need to use APIs in torchvision.transforms.functional or in torchvision.transforms.v2.functional. warnings.warn(

Java中@FunctionalInterface

torch.nn.functional详解

怎么导入cuda_functional

java注解@FunctionalInterface

@FunctionalInterface注解修饰的方法

nn.functional如何使用

nn.functional.interpolate

@FunctionalInterface注解

最新资源

UserWarning: The torchvision.transforms.functional_tensor module is deprecated in 0.15 and will be removed in 0.17. Please don't rely on it. You probably just need to use APIs in torchvision.transforms.functional or in torchvision.transforms.v2.functional. warnings.warn(