函數式編程圖解 Grokking Functional Programming

米哈爾·普瓦赫塔（Micha? P?achta）是一位經驗豐富的軟件工程師，也活躍於函數式編程社區。他經常在技術會議上發言，主持研討會，組織聚會，並在博客上發表文章，探討如何創建可維護的軟件。

目　　錄

 

第I部分　函數式工具包

第1章　學習函數式編程 3

1.1　也許你選擇本書是因為……4

1.2　你應掌握的背景知識 5

1.3　函數是什麽樣的 6

1.4　認識函數 7

1.5　當代碼說謊時…… 8

1.6　命令式與聲明式 9

1.7　小憩片刻：命令式與聲明式 10

1.8　解釋：命令式與聲明式 11

1.9　學習函數式編程的益處 12

1.10　進入Scala 13

1.11　練慣用Scala編寫函數 14

1.12　準備工具 15

1.13　瞭解REPL 16

1.14　編寫你的第一個函數 17

1.15　如何使用本書 18

小結 19

 

第2章　純函數 21

2.1　為什麽需要純函數 22

2.2　命令式編碼 23

2.3　破譯代碼 24

2.4　傳遞數據的副本 25

2.5　再次破譯代碼…… 26

2.6　重新計算而不是存儲 27

2.7　通過傳遞狀態來集中於邏輯 28

2.8　狀態去哪兒了 29

2.9　純函數和非純函數之間的區別 30

2.10　小憩片刻：將命令式代碼重構為純函數 31

2.11　解釋：將命令式代碼重構為純函數 32

2.12　純函數是值得信任的 34

2.13　程序語言中的純函數 35

2.14　保持純函數的難度…… 36

2.15　純函數和清潔代碼 37

2.16　小憩片刻：純函數還是非純函數 38

2.17　解釋：純函數還是非純函數 39

2.18　使用Scala編寫純函數 40

2.19　用Scala練習純函數 41

2.20　測試純函數 42

2.21　小憩片刻：測試純函數 43

2.22　解釋：測試純函數 44

小結 45

 

第3章　不可變值 47

3.1　引擎的燃料 48

3.2　不可變性的另一種情況 49

3.3　你會相信這個函數嗎 50

3.4　可變性是危險的 51

3.5　回顧：說謊的函數…… 52

3.6　使用副本對抗可變性 53

3.7　小憩片刻：可變性帶來的困擾 54

3.8　解釋：可變性帶來的困擾 55

3.9　引入共享可變狀態 58

3.10　狀態對編程能力的影響 59

3.11　處理移動部分 60

3.12　使用FP處理移動部分 61

3.13　Scala中的不可變值 62

3.14　建立對不可變性的直覺 63

3.15　小憩片刻：不可變的

String API 64

3.16　解釋：不可變的String API 65

3.17　等等，這不是更糟糕嗎 66

3.18　純函數解法解決共享可變狀態問題 67

3.19　練習不可變的切分和追加 69

小結 70

 

第4章　函數作為值 71

4.1　將要求實現為函數 72

4.2　非純函數和可變值反擊 73

4.3　使用Java Streams對列表進行排序 74

4.4　函數特徵標記應說明全部情況 75

4.5　更改要求 76

4.6　只是在傳遞代碼 77

4.7　使用Java的Function值 78

4.8　使用Function語法處理代碼重復問題 79

4.9　將用戶定義的函數作為參數傳遞 80

4.10　小憩片刻：將函數作為參數 81

4.11　解釋：將函數作為參數 82

4.12　閱讀函數式Java的問題 83

4.13　在Scala中傳遞函數 84

4.14　深入瞭解sortBy 85

4.15　在Scala中具有函數參數的特徵標記 86

4.16　在Scala中將函數作為參數傳遞 87

4.17　練習函數傳遞 88

4.18　採用聲明式編程 89

4.19　將函數傳遞給自定義函數 90

4.20　小函數及其職責 91

4.21　內聯傳遞函數 92

4.22　小憩片刻：在Scala中傳遞函數 93

4.23　解釋：在Scala中傳遞函數 94

4.24　僅通過傳遞函數還能實現什麽功能呢 95

4.25　將函數應用於列表中的每個元素 96

4.26　使用map將函數應用於列表的每個元素 97

4.27　瞭解map 98

4.28　練習使用map 99

4.29　學習一次，隨處適用 100

4.30　根據條件返回列表的部分內容 101

4.31　使用filter返回列表的部分內容 102

4.32　瞭解filter 103

4.33　練習filter 104

4.34　迄今為止的旅程…… 105

4.35　避免重復自己 106

4.36　API是否易於使用 107

4.37　添加一個新參數不足以解決問題 108

4.38　函數可以返回函數 109

4.39　使用可以返回函數的函數 110

4.40　函數就是值 111

4.41　小憩片刻：返回函數 112

4.42　解釋：返回函數 113

4.43　設計函數式API 114

4.44　函數式API的迭代設計 115

4.45　從返回的函數中返回函數 116

4.46　如何從返回的函數中返回函數 117

4.47　使用返回函數構建的靈活API 118

4.48　在函數中使用多個參數列表 119

4.49　使用柯里化 120

4.50　練習柯里化 121

4.51　通過傳遞函數值進行編程 122

4.52　將許多值縮減為單個值 123

4.53　使用foldLeft將多個值縮減為一個 124

4.54　瞭解foldLeft 125

4.55　foldLeft用者須知 126

4.56　練習foldLeft 127

4.57　建模不可變量據 128

4.58　使用具有高階函數的求積類型 129

4.59　內聯函數的更簡潔語法 130

小結 131

 

第II部分　函數式程序

第5章　順序程序 135

5.1　編寫基於流水線的算法 136

5.2　根據小模塊構建大型程序 137

5.3　命令式解法 138

5.4　flatten和flatMap 139

5.5　使用多個flatMap的實際案例 140

5.6　flatMap和列表大小的更改 141

5.7　小憩片刻：處理由列表組成的列表 142

5.8　解釋：處理由列表組成的列表 143

5.9　連接的flatMap和map 144

5.10　嵌套的flatMap 145

5.11　依賴其他值的值 146

5.12　練習嵌套的flatMap 147

5.13　更好的嵌套 flatMap 語法 148

5.14　使用for推導式 149

5.15　小憩片刻：flatMap與for推導式 150

5.16　解釋：flatMap與for推導式 151

5.17　瞭解for推導式 152

5.18　這不是你想要的for 153

5.19　在for推導式內部 154

5.20　更復雜的for推導式 155

5.21　使用for推導式檢查所有組合 156

5.22　過濾技術 157

5.23　小憩片刻：過濾技術 158

5.24　解釋：過濾技術 159

5.25　抽象化 160

5.26　比較map、foldLeft和flatMap 161

5.27　使用Set的for推導式 162

5.28　使用多種類型的for推導式 163

5.29　練習for推導式 164

5.30　再次定義for推導式 165

5.31　使用非集合類型的for推導式 166

5.32　避免null函數：Option類型 167

5.33　解析為流水線 168

5.34　小憩片刻：使用Option進行解析 169

5.35　解釋：使用Option進行解析 170

小結 171

 

第6章　錯誤處理 173

6.1　從容處理許多不同的錯誤 174

6.2　是否可能處理所有問題 175

6.3　按照播出時長對電視節目列表進行排序 176

6.4　實現排序要求 177

6.5　處理來自外部世界的數據 178

6.6　函數式設計：利用小代碼塊構建 179

6.7　將String解析為不可變對象 180

6.8　解析一個List只是解析一個元素 181

6.9　將String解析為TvShow 182

6.10　如何處理潛在錯誤 183

6.11　返回null是不是一個好辦法 184

6.12　如何更從容地處理潛在錯誤 185

6.13　實現返回Option的函數 186

6.14　Option強制處理可能的錯誤 187

6.15　基於小代碼塊進行構建 188

6.16　函數式設計是基於小代碼塊進行構建 189

6.17　編寫一個小而安全的函數，使其返回一個Option 190

6.18　函數、值和表達式 192

6.19　練習返回Option的安全函數 193

6.20　錯誤如何傳播 194

6.21　值代表錯誤 195

6.22　Option、for推導式和已檢查的異常 196

6.23　已檢查異常怎麽樣 197

6.24　條件恢復 198

6.25　使用命令式風格進行條件恢復 199

6.26　使用函數式的條件恢復 200

6.27　已檢查異常不可組合，但Option可以 201

6.28　orElse的工作原理 202

6.29　練習函數式錯誤處理 203

6.30　即使存在錯誤，仍組合函數 204

6.31　編譯器提醒需要覆蓋錯誤 205

6.32　編譯錯誤對我們有好處 206

6.33　將由Option組成的List轉換為扁平 List 207

6.34　讓編譯器成為我們的向導 208

6.35　不要過於相信編譯器 209

6.36　小憩片刻：錯誤處理策略 210

6.37　解釋：錯誤處理策略 211

6.38　兩種不同的錯誤處理策略 212

6.39　孤註一擲錯誤處理策略 213

6.40　將Option組成的List折疊為一個List的Option 214

6.41　現已知道如何處理多個可能的錯誤 215

6.42　如何知道哪裡出錯了 216

6.43　需要在返回值中傳達錯誤的詳細信息 217

6.44　使用Either傳達錯誤詳情 218

6.45　重構以使用Either 219

6.46　返回Either而不是Option 220

6.47　練習返回Either的安全函數 223

6.48　學到的Option相關知識也適用於Either 224

6.49　小憩片刻：使用Either進行錯誤處理 225

6.50　解釋：用Either進行錯誤處理 226

6.51　使用Option/Either進行工作 227

小結 228

 

第7章　作為類型的要求 229

7.1　建模數據以盡量減少程序員的錯誤 230

7.2　精心建模的數據不會說謊 231

7.3　使用已知內容(即原始類型)進行設計 232

7.4　使用建模為原始類型的數據 233

7.5　小憩片刻：原始類型之苦 234

7.6　解釋：原始類型之苦 235

7.7　使用原始類型建模的問題 236

7.8　使用原始類型加大工作難度 237

7.9　newtype使參數不被錯放 238

7.10　在數據模型中使用newtype 239

7.11　練習newtype 240

7.12　確保只存在有效數據組合 241

7.13　建模數據缺失的可能性 242

7.14　模型變化導致邏輯變化 243

7.15　在邏輯中使用建模為Option的數據 244

7.16　高階函數獲勝 245

7.17　可能存在符合要求的高階函數 246

7.18　小憩片刻：forall/exists/contains 247

7.19　解釋：forall/exists/contains 248

7.20　將概念耦合在單個求積類型內 249

7.21　建模有限可能性 250

7.22　使用求和類型 251

7.23　使用求和類型改善模型 252

7.24　使用“求和類型+求積類型”的組合 253

7.25　求積類型+求和類型=代數數據類型 254

7.26　在行為(函數)中使用基於ADT的模型 255

7.27　使用模式匹配解構ADT 256

7.28　重復和DRY 257

7.29　練習模式匹配 258

7.30　實際應用中的newtype、ADT和模式匹配 259

7.31　如何繼承呢 260

7.32　小憩片刻：函數式數據設計 261

7.33　解釋：函數式數據設計 262

7.34　建模行為 263

7.35　將行為建模為數據 264

7.36　使用基於ADT的參數實現函數 265

7.37　小憩片刻：設計與可維護性 266

7.38　解釋：設計與可維護性 267

小結 268

 

第8章　作為值的IO 269

8.1　與外界交流 270

8.2　與外部 API 集成 271

8.3　具有副作用的IO操作的屬性 272

8.4　帶有副作用的IO代碼的命令式解決方案 273

8.5　命令式IO方案存在許多問題 274

8.6　能通過FP完善方案嗎 275

8.7　執行IO與使用IO的結果 276

8.8　命令式處理IO 277

8.9　作為IO值的計算 278

8.10　IO 值 279

8.11　實際運行中的IO值 280

8.12　將非純性排出 281

8.13　使用從兩個IO操作獲取的值 282

8.14　將兩個IO值組合成單個IO值 283

8.15　練習創建和組合IO值 284

8.16　僅使用值來解決問題 285

8.17　IO類型是病毒性的 286

8.18　小憩片刻：使用值 287

8.19　解釋：使用值 288

8.20　向函數式IO前進 289

8.21　如何處理IO故障 290

8.22　運行由IO描述的程序可能會失敗 291

8.23　記得orElse嗎 292

8.24　惰性求值和及早求值 293

8.25　使用IO.orElse實現恢復策略 294

8.26　使用orElse和pure實現回退 295

8.27　練習IO值的故障恢復 296

8.28　應該在哪裡處理潛在的故障 297

8.29　具有故障處理的函數IO 298

8.30　純函數不會說謊，即使在

不安全的世界中也是如此 299

8.31　函數式架構 300

8.32　使用IO存儲數據 301

8.33　小憩片刻：使用IO存儲數據 304

8.34　解釋：使用IO存儲數據 305

8.35　將一切視為值 306

8.36　將重試作為值處理 307

8.37　將未知數量的API調用視為值 309

8.38　練習：培養函數特徵標記的直覺 311

小結 312

 

第9章　作為值的流 313

9.1　無限超越 314

9.2　處理未知數量的值 315

9.3　處理外部非純的API調用(再次) 316

9.4　函數式設計方案 317

9.5　不可變映射 318

9.6　練習不可變映射 319

9.7　應該進行多少IO調用 320

9.8　自下而上的設計 321

9.9　高級列表操作 322

9.10　引入元組 323

9.11　zip和drop 324

9.12　元組模式匹配 325

9.13　小憩片刻：使用映射和元組 326

9.14　解釋：使用映射和元組 327

9.15　函數拼圖 328

9.16　跟蹤自下而上設計中的類型 329

9.17　原型製作和死衚衕 330

9.18　遞歸函數 331

9.19　無限和惰性 332

9.20　遞歸函數結構 333

9.21　處理未來的空值(使用遞歸函數) 334

9.22　無限遞歸調用的有用性 335

9.23　小憩片刻：遞歸和無限 336

9.24　解釋：遞歸和無限 337

9.25　使用遞歸創建不同的IO程序 338

9.26　使用遞歸進行任意數量的調用 339

9.27　遞歸版本的問題 340

9.28　引入數據流 341

9.29　命令式語言中的Stream 342

9.30　按需生成值 343

9.31　流處理、生產者和消費者 344

9.32　流和IO 345

9.33　函數式Stream 346

9.34　FP中的流是值 347

9.35　流是遞歸值 348

9.36　原始操作和組合器 349

9.37　基於IO值的流 350

9.38　基於IO值的無限流 351

9.39　為副作用而執行 352

9.40　練習流操作 353

9.41　利用流的功能 354

9.42　API調用的無限流 355

9.43　在流中處理IO故障 356

9.44　分離的關註點 357

9.45　滑動窗口 358

9.46　等待IO調用 360

9.47　組合流 361

9.48　使用基於流的方案的好處 362

小結 363

 

第10章　並發程序 365

10.1　無處不在的線程 366

10.2　聲明式並發 367

10.3　順序與並發 368

10.4　小憩片刻：順序性思考 369

10.5　解釋：順序性思考 370

10.6　需要進行批處理 371

10.7　批處理實現 372

10.8　並發世界 373

10.9　並發狀態 374

10.10　命令式並發 375

10.11　原子引用 377

10.12　引入Ref 378

10.13　更新Ref值 379

10.14　使用Ref值 380

10.15　讓一切並行運行 381

10.16　parSequence的實際應用 382

10.17　練習並發IO 384

10.18　建模並發性 385

10.19　使用Ref和Fiber進行編碼 386

10.20　無限運行的IO 388

10.21　小憩片刻：並發性思考 389

10.22　解釋：並發性思考 390

10.23　需要異步性 391

10.24　為異步訪問做準備 392

10.25　設計函數式異步程序 393

10.26　手動管理Fiber 394

10.27　編寫函數式異步程序 395

小結 396

 

第III部分　應用函數式編程

第11章　設計函數式程序 399

11.1　有效、準確、快速 400

11.2　使用不可變值建模 401

11.3　業務領域建模和FP 402

11.4　數據訪問建模 403

11.5　函數包 404

11.6　作為純函數的業務邏輯 405

11.7　分離真正的數據訪問問題 406

11.8　使用命令式庫和IO與API集成 407

11.9　遵循設計 410

11.10　將輸入操作作為IO值實現 411

11.11　將庫IO與其他關註點分離 413

11.12　柯里化和控制反轉 414

11.13　作為值的函數 415

11.14　串聯知識 416

11.15　我們做到了 417

11.16　使業務邏輯正確 418

11.17　資源泄漏 419

11.18　處理資源 420

11.19　使用Resource值 421

11.20　我們做對了 422

11.21　小憩片刻：加快速度 423

11.22　解釋：加快速度 424

小結 425

 

第12章　測試函數式程序 427

12.1　你對其進行測試嗎 428

12.2　測試只是函數 429

12.3　選擇要測試的函數 430

12.4　提供示例進行測試 431

12.5　通過示例練習測試 432

12.6　生成好示例 433

12.7　生成屬性 434

12.8　基於屬性的測試 435

12.9　提供屬性進行測試 436

12.10　通過傳遞函數來委派工作 437

12.11　瞭解基於屬性測試的失敗原因 438

12.12　測試錯誤還是存在錯誤 439

12.13　自定義生成器 440

12.14　使用自定義生成器 441

12.15　以可讀的方式測試更復雜的場景 442

12.16　查找並修復實現中的錯誤 443

12.17　小憩片刻：基於屬性的測試 444

12.18　解釋：基於屬性的測試 445

12.19　屬性和示例 446

12.20　要求範圍 447

12.21　測試具有副作用的要求 448

12.22　確定工作所需的正確測試 449

12.23　數據使用測試 450

12.24　練習使用IO存根外部服務 452

12.25　測試和設計 453

12.26　服務集成測試 454

12.27　本地服務器作為集成測試中的資源 455

12.28　編寫單獨集成測試 456

12.29　與服務集成是單一職責 457

12.30　小憩片刻：編寫集成測試 458

12.31　解釋：編寫集成測試 459

12.32　集成測試耗時更長 460

12.33　基於屬性的集成測試 461

12.34　選擇正確的測試方案 462

12.35　測試驅動開發 463

12.36　為不存在的功能編寫測試 464

12.37　紅綠重構 465

12.38　讓測試通過 466

12.39　增加紅色測試 467

12.40　最後的TDD迭代 468

小結 469

結語 470

 

——以下內容可通過掃描封底二維碼下載——

附錄A　Scala 速查表 471

附錄B　函數式重點 477