函数化编程思想探索 - Functional Thinking

5星 · 超过95%的资源需积分: 9 63 浏览量更新于2024-07-22 3 收藏 7.7MB PDF 举报

"Functional Thinking.pdf" 是一本由 Neal Ford 撰写的关于函数化编程思想的书籍，探讨了如何运用函数式编程的思维方式来解决问题。该书由 O'Reilly Media 出版，适合教育、商业或销售推广使用，并提供在线版本。在函数式编程中，程序被视为数学函数的组合，强调数据的不可变性和纯函数（即没有副作用的函数）。这种编程范式鼓励使用高阶函数，如 map、reduce 和 filter，以及函数组合，以减少状态和副作用，提高代码的可读性和可维护性。本书可能涵盖了以下关键知识点： 1. **函数式编程基础**：介绍函数式编程的基本概念，如λ演算、函数定义、纯函数、柯里化（Currying）和模式匹配等。 2. **不可变数据结构**：讲解如何利用不可变数据结构来避免数据修改导致的复杂性，以及它们在并行处理中的优势。 3. **高阶函数**：深入讨论 map、reduce、filter 等高阶函数的用法，以及如何通过这些函数来处理集合和数据流。 4. **函数组合**：解释如何通过组合小函数构建更复杂的逻辑，以保持代码简洁。 5. **递归**：阐述函数式编程中广泛使用的递归原理，包括如何编写正确的递归函数以及如何避免无限递归。 6. **Monads**：介绍 Monad 这一概念，它是函数式编程中的一个抽象构造，用于处理副作用和控制流。 7. **函数式语言特性**：可能涵盖一些特定的函数式编程语言，如 Haskell、Scala、Clojure 或 F#，以及它们的语法特性和适用场景。 8. **函数式编程与面向对象编程的对比**：探讨两种编程范式的异同，以及在特定问题上如何选择合适的范式。 9. **函数式编程的实际应用**：可能包含函数式编程在实际开发中的应用案例，如在大数据处理、并发编程和Web开发中的使用。 10. **函数式编程的挑战与优势**：讨论函数式编程可能面临的挑战，如学习曲线较陡峭，以及它所带来的优势，如代码的简洁性、可测试性和并发性能。这本书的读者群体可能包括希望了解和掌握函数式编程的软件开发者，尤其是那些已经在面向对象编程环境中工作并寻求新的思考方式的人。通过阅读本书，读者将能够理解和实践函数化编程思想，提升自己的编程技能和解决问题的能力。

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

www.it-ebooks.info

}

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

www.it-ebooks.info

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

www.it-ebooks.info

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

www.it-ebooks.info

“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

www.it-ebooks.info

剩余178页未读，继续阅读

liu9x9

粉丝: 0
资源: 17

函数化编程思想探索 - Functional Thinking

"留言板设计毕业设计.pdf：需求分析和总体设计

MIL-STD-1366E.002979.pdf文件下载及来源解析

"TI LVDS缓冲器TI-SN65CML100.pdf功能描述及应用

Functional Thinking

Functional C#[January 2017].pdf

Java.9.Data.Structures.and.Algorithms.2017.4.pdf

函数式swift.pdf

20个面试经典问答双语版一.pdf

Sams Teach Yourself Microsoft Expression Web 3 in 24 Hours.pdf

Functional Programming pdf 2018

最新资源