函數式編程圖解

作者：(波蘭)米哈爾·普瓦赫塔|責編:王軍//劉遠菁|譯者:郭濤
出版社：清華大學
ISBN：9787302679288

出版日期：2025/02/01
裝幀：平裝
頁數：469

人民幣：RMB 168 元售價：元

內容大鋼

《函數式編程圖解》旨在以通俗易懂的方式向命令式開發人員介紹函數式編程。從簡短的編程任務開始，逐一引入諸如純函數和不可變數據等基本概念，並在此過程中穿插講解如何消除由複雜分散式狀態引起的常見錯誤，適時探索IO、併發和數據流的函數式處理方式。讀完本書後，你便能輕鬆編寫出易於理解、測試和維護的簡潔函數式代碼。

作者介紹

(波蘭)米哈爾·普瓦赫塔|責編:王軍//劉遠菁|譯者:郭濤

第I部分  函數式工具包
  第1章  學習函數式編程
    1.1  也許你選擇本書是因為……
    1.2  你應掌握的背景知識
    1.3  函數是什麼樣的
    1.4  認識函數
    1.5  當代碼說謊時……
    1.6  命令式與聲明式
    1.7  小憩片刻：命令式與聲明式
    1.8  解釋：命令式與聲明式
    1.9  學習函數式編程的益處
    1.10  進入Scala
    1.11  練慣用Scala編寫函數
    1.12  準備工具
    1.13  了解REPL
    1.14  編寫你的第一個函數
    1.15  如何使用本書
    小結
  第2章  純函數
    2.1  為什麼需要純函數
    2.2  命令式編碼
    2.3  破譯代碼
    2.4  傳遞數據的副本
    2.5  再次破譯代碼……
    2.6  重新計算而不是存儲
    2.7  通過傳遞狀態來集中於邏輯
    2.8  狀態去哪兒了
    2.9  純函數和非純函數之間的區別
    2.10  小憩片刻：將命令式代碼重構為純函數
    2.11  解釋：將命令式代碼重構為純函數
    2.12  純函數是值得信任的
    2.13  程序語言中的純函數
    2.14  保持純函數的難度……
    2.15  純函數和清潔代碼
    2.16  小憩片刻：純函數還是非純函數
    2.17  解釋：純函數還是非純函數
    2.18  使用Scala編寫純函數
    2.19  用Scala練習純函數
    2.20  測試純函數
    2.21  小憩片刻：測試純函數
    2.22  解釋：測試純函數
    小結
  第3章  不可變值
    3.1  引擎的燃料
    3.2  不可變性的另一種情況
    3.3  你會相信這個函數嗎
    3.4  可變性是危險的
    3.5  回顧：說謊的函數……
    3.6  使用副本對抗可變性
    3.7  小憩片刻：可變性帶來的困擾

    3.8  解釋：可變性帶來的困擾
    3.9  引入共享可變狀態
    3.10  狀態對編程能力的影響
    3.11  處理移動部分
    3.12  使用FP處理移動部分
    3.13  Scala中的不可變值
    3.14  建立對不可變性的直覺
    3.15  小憩片刻：不可變的String API
    3.16  解釋：不可變的String API
    3.17  等等，這不是更糟糕嗎
    3.18  純函數解法解決共享可變狀態問題
    3.19  練習不可變的切分和追加
    小結
  第4章  函數作為值
    4.1  將要求實現為函數
    4.2  非純函數和可變值反擊
    4.3  使用Java Streams對列表進行排序
    4.4  函數特徵標記應說明全部情況
    4.5  更改要求
    4.6  只是在傳遞代碼
    4.7  使用Java的Function值
    4.8  使用Function語法處理代碼重複問題
    4.9  將用戶定義的函數作為參數傳遞
    4.10  小憩片刻：將函數作為參數
    4.11  解釋：將函數作為參數
    4.12  閱讀函數式Java的問題
    4.13  在Scala中傳遞函數
    4.14  深入了解sortBy
    4.15  在Scala中具有函數參數的特徵標記
    4.16  在Scala中將函數作為參數傳遞
    4.17  練習函數傳遞
    4.18  採用聲明式編程
    4.19  將函數傳遞給自定義函數
    4.20  小函數及其職責
    4.21  內聯傳遞函數
    4.22  小憩片刻：在Scala中傳遞函數
    4.23  解釋：在Scala中傳遞函數
    4.24  僅通過傳遞函數還能實現什麼功能呢
    4.25  將函數應用於列表中的每個元素
    4.26  使用map將函數應用於列表的每個元素
    4.27  了解map
    4.28  練習使用map
    4.29  學習一次，隨處適用
    4.30  根據條件返回列表的部分內容
    4.31  使用filter返回列表的部分內容
    4.32  了解filter
    4.33  練習filter
    4.34  迄今為止的旅程……
    4.35  避免重複自己
    4.36  API是否易於使用

    4.37  添加一個新參數不足以解決問題
    4.38  函數可以返回函數
    4.39  使用可以返回函數的函數
    4.40  函數就是值
    4.41  小憩片刻：返回函數
    4.42  解釋：返回函數
    4.43  設計函數式API
    4.44  函數式API的迭代設計
    4.45  從返回的函數中返回函數
    4.46  如何從返回的函數中返回函數
    4.47  使用返回函數構建的靈活API
    4.48  在函數中使用多個參數列表
    4.49  使用柯里化
    4.50  練習柯里化
    4.51  通過傳遞函數值進行編程
    4.52  將許多值縮減為單個值
    4.53  使用foldLeft將多個值縮減為一個
    4.54  了解foldLeft
    4.55  foldLeft用者須知
    4.56  練習foldLeft
    4.57  建模不可變數據
    4.58  使用具有高階函數的求積類型
    4.59  內聯函數的更簡潔語法
    小結
第II部分  函數式程序
  第5章  順序程序
    5.1  編寫基於流水線的演算法
    5.2  根據小模塊構建大型程序
    5.3  命令式解法
    5.4  flatten和flatMap
    5.5  使用多個flatMap的實際案例
    5.6  flatMap和列表大小的更改
    5.7  小憩片刻：處理由列表組成的列表
    5.8  解釋：處理由列表組成的列表
    5.9  連接的flatMap和map
    5.10  嵌套的flatMap
    5.11  依賴其他值的值
    5.12  練習嵌套的flatMap
    5.13  更好的嵌套flatMap語法
    5.14  使用for推導式
    5.15  小憩片刻：flatMap與for推導式
    5.16  解釋：flatMap與for推導式
    5.17  了解for推導式
    5.18  這不是你想要的for
    5.19  在for推導式內部
    5.20  更複雜的for推導式
    5.21  使用for推導式檢查所有組合
    5.22  過濾技術
    5.23  小憩片刻：過濾技術
    5.24  解釋：過濾技術

    5.25  抽象化
    5.26  比較map、foldLeft和flatMap
    5.27  使用Set的for推導式
    5.28  使用多種類型的for推導式
    5.29  練習for推導式
    5.30  再次定義for推導式
    5.31  使用非集合類型的for推導式
    5.32  避免null函數：Option類型
    5.33  解析為流水線
    5.34  小憩片刻：使用Option進行解析
    5.35  解釋：使用Option進行解析
    小結
  第6章  錯誤處理
    6.1  從容處理許多不同的錯誤
    6.2  是否可能處理所有問題
    6.3  按照播出時長對電視節目列表進行排序
    6.4  實現排序要求
    6.5  處理來自外部世界的數據
    6.6  函數式設計：利用小代碼塊構建
    6.7  將String解析為不可變對象
    6.8  解析一個List只是解析一個元素
    6.9  將String解析為TvShow
    6.10  如何處理潛在錯誤
    6.11  返回null是不是一個好辦法
    6.12  如何更從容地處理潛在錯誤
    6.13  實現返回Option的函數
    6.14  Option強制處理可能的錯誤
    6.15  基於小代碼塊進行構建
    6.16  函數式設計是基於小代碼塊進行構建
    6.17  編寫一個小而安全的函數，使其返回一個Option
    6.18  函數、值和表達式
    6.19  練習返回Option的安全函數
    6.20  錯誤如何傳播
    6.21  值代表錯誤
    6.22  Option、for推導式和已檢查的異常
    6.23  已檢查異常怎麼樣
    6.24  條件恢復
    6.25  使用命令式風格進行條件恢復
    6.26  使用函數式的條件恢復
    6.27  已檢查異常不可組合，但Option可以
    6.28  orElse的工作原理
    6.29  練習函數式錯誤處理
    6.30  即使存在錯誤，仍組合函數
    6.31  編譯器提醒需要覆蓋錯誤
    6.32  編譯錯誤對我們有好處
    6.33  將由Option組成的List轉換為扁平List
    6.34  讓編譯器成為我們的嚮導
    6.35  不要過於相信編譯器
    6.36  小憩片刻：錯誤處理策略
    6.37  解釋：錯誤處理策略

    6.38  兩種不同的錯誤處理策略
    6.39  孤注一擲錯誤處理策略
    6.40  將Option組成的List摺疊為一個List的Option
    6.41  現已知道如何處理多個可能的錯誤
    6.42  如何知道哪裡出錯了
    6.43  需要在返回值中傳達錯誤的詳細信息
    6.44  使用Either傳達錯誤詳情
    6.45  重構以使用Either
    6.46  返回Either而不是Option
    6.47  練習返回Either的安全函數
    6.48  學到的Option相關知識也適用於Either
    6.49  小憩片刻：使用Either進行錯誤處理
    6.50  解釋：用Either進行錯誤處理
    6.51  使用Option/Either進行工作
    小結
  第7章  作為類型的要求
    7.1  建模數據以盡量減少程序員的錯誤
    7.2  精心建模的數據不會說謊
    7.3  使用已知內容（即原始類型）進行設計
    7.4  使用建模為原始類型的數據
    7.5  小憩片刻：原始類型之苦
    7.6  解釋：原始類型之苦
    7.7  使用原始類型建模的問題
    7.8  使用原始類型加大工作難度
    7.9  newtype使參數不被錯放
    7.10  在數據模型中使用newtype
    7.11  練習newtype
    7.12  確保只存在有效數據組合
    7.13  建模數據缺失的可能性
    7.14  模型變化導致邏輯變化
    7.15  在邏輯中使用建模為Option的數據
    7.16  高階函數獲勝
    7.17  可能存在符合要求的高階函數
    7.18  小憩片刻：forall/exists/contains
    7.19  解釋：forall/exists/contains
    7.20  將概念耦合在單個求積類型內
    7.21  建模有限可能性
    7.22  使用求和類型
    7.23  使用求和類型改善模型
    7.24  使用「求和類型+求積類型」的組合
    7.25  求積類型+求和類型=代數數據類型
    7.26  在行為（函數）中使用基於ADT的模型
    7.27  使用模式匹配解構ADT
    7.28  重複和DRY
    7.29  練習模式匹配
    7.30  實際應用中的newtype、ADT和模式匹配
    7.31  如何繼承呢
    7.32  小憩片刻：函數式數據設計
    7.33  解釋：函數式數據設計
    7.34  建模行為

    7.35  將行為建模為數據
    7.36  使用基於ADT的參數實現函數
    7.37  小憩片刻：設計與可維護性
    7.38  解釋：設計與可維護性
    小結
  第8章  作為值的IO
    8.1  與外界交流
    8.2  與外部API集成
    8.3  具有副作用的IO操作的屬性
    8.4  帶有副作用的IO代碼的命令式解決方案
    8.5  命令式IO方案存在許多問題
    8.6  能通過FP完善方案嗎
    8.7  執行IO與使用IO的結果
    8.8  命令式處理IO
    8.9  作為IO值的計算
    8.10  IO值
    8.11  實際運行中的IO值
    8.12  將非純性排出
    8.13  使用從兩個IO操作獲取的值
    8.14  將兩個IO值組合成單個IO值
    8.15  練習創建和組合IO值
    8.16  僅使用值來解決問題
    8.17  IO類型是病毒性的
    8.18  小憩片刻：使用值
    8.19  解釋：使用值
    8.20  向函數式IO前進
    8.21  如何處理IO故障
    8.22  運行由IO描述的程序可能會失敗
    8.23  記得orElse嗎
    8.24  惰性求值和及早求值
    8.25  使用IO.orElse實現恢復策略
    8.26  使用orElse和pure實現回退
    8.27  練習IO值的故障恢復
    8.28  應該在哪裡處理潛在的故障
    8.29  具有故障處理的函數IO
    8.30  純函數不會說謊，即使在不安全的世界中也是如此
    8.31  函數式架構
    8.32  使用IO存儲數據
    8.33  小憩片刻：使用IO存儲數據
    8.34  解釋：使用IO存儲數據
    8.35  將一切視為值
    8.36  將重試作為值處理
    8.37  將未知數量的API調用視為值
    8.38  練習：培養函數特徵標記的直覺
    小結
  第9章  作為值的流
    9.1  無限超越
    9.2  處理未知數量的值
    9.3  處理外部非純的API調用（再次）
    9.4  函數式設計方案

    9.5  不可變映射
    9.6  練習不可變映射
    9.7  應該進行多少IO調用
    9.8  自下而上的設計
    9.9  高級列表操作
    9.10  引入元組
    9.11  zip和drop
    9.12  元組模式匹配
    9.13  小憩片刻：使用映射和元組
    9.14  解釋：使用映射和元組
    9.15  函數拼圖
    9.16  跟蹤自下而上設計中的類型
    9.17  原型製作和死衚衕
    9.18  遞歸函數
    9.19  無限和惰性
    9.20  遞歸函數結構
    9.21  處理未來的空值（使用遞歸函數）
    9.22  無限遞歸調用的有用性
    9.23  小憩片刻：遞歸和無限
    9.24  解釋：遞歸和無限
    9.25  使用遞歸創建不同的IO程序
    9.26  使用遞歸進行任意數量的調用
    9.27  遞歸版本的問題
    9.28  引入數據流
    9.29  命令式語言中的Stream
    9.30  按需生成值
    9.31  流處理、生產者和消費者
    9.32  流和IO
    9.33  函數式Stream
    9.34  FP中的流是值
    9.35  流是遞歸值
    9.36  原始操作和組合器
    9.37  基於IO值的流
    9.38  基於IO值的無限流
    9.39  為副作用而執行
    9.40  練習流操作
    9.41  利用流的功能
    9.42  API調用的無限流
    9.43  在流中處理IO故障
    9.44  分離的關注點
    9.45  滑動窗口
    9.46  等待IO調用
    9.47  組合流
    9.48  使用基於流的方案的好處
    小結
  第10章  併發程序
    10.1  無處不在的線程
    10.2  聲明式併發
    10.3  順序與併發
    10.4  小憩片刻：順序性思考

    10.5  解釋：順序性思考
    10.6  需要進行批處理
    10.7  批處理實現
    10.8  併發世界
    10.9  併發狀態
    10.10  命令式併發
    10.11  原子引用
    10.12  引入Ref
    10.13  更新Ref值
    10.14  使用Ref值
    10.15  讓一切並行運行
    10.16  parSequence的實際應用
    10.17  練習併發IO
    10.18  建模併發性
    10.19  使用Ref和Fiber進行編碼
    10.20  無限運行的IO
    10.21  小憩片刻：併發性思考
    10.22  解釋：併發性思考
    10.23  需要非同步性
    10.24  為非同步訪問做準備
    10.25  設計函數式非同步程序
    10.26  手動管理Fiber
    10.27  編寫函數式非同步程序
    小結
第III部分  應用函數式編程
  第11章  設計函數式程序
    11.1  有效、準確、快速
    11.2  使用不可變值建模
    11.3  業務領域建模和FP
    11.4  數據訪問建模
    11.5  函數包
    11.6  作為純函數的業務邏輯
    11.7  分離真正的數據訪問問題
    11.8  使用命令式庫和IO與API集成
    11.9  遵循設計
    11.10  將輸入操作作為IO值實現
    11.11  將庫IO與其他關注點分離
    11.12  柯里化和控制反轉
    11.13  作為值的函數
    11.14  串聯知識
    11.15  我們做到了
    11.16  使業務邏輯正確
    11.17  資源泄漏
    11.18  處理資源
    11.19  使用Resource值
    11.20  我們做對了
    11.21  小憩片刻：加快速度
    11.22  解釋：加快速度
    小結
  第12章  測試函數式程序

    12.1  你對其進行測試嗎
    12.2  測試只是函數
    12.3  選擇要測試的函數
    12.4  提供示例進行測試
    12.5  通過示例練習測試
    12.6  生成好示例
    12.7  生成屬性
    12.8  基於屬性的測試
    12.9  提供屬性進行測試
    12.10  通過傳遞函數來委派工作
    12.11  了解基於屬性測試的失敗原因
    12.12  測試錯誤還是存在錯誤
    12.13  自定義生成器
    12.14  使用自定義生成器
    12.15  以可讀的方式測試更複雜的場景
    12.16  查找並修復實現中的錯誤
    12.17  小憩片刻：基於屬性的測試
    12.18  解釋：基於屬性的測試
    12.19  屬性和示例
    12.20  要求範圍
    12.21  測試具有副作用的要求
    12.22  確定工作所需的正確測試
    12.23  數據使用測試
    12.24  練習使用IO存根外部服務
    12.25  測試和設計
    12.26  服務集成測試
    12.27  本地伺服器作為集成測試中的資源
    12.28  編寫單獨集成測試
    12.29  與服務集成是單一職責
    12.30  小憩片刻：編寫集成測試
    12.31  解釋：編寫集成測試
    12.32  集成測試耗時更長
    12.33  基於屬性的集成測試
    12.34  選擇正確的測試方案
    12.35  測試驅動開發
    12.36  為不存在的功能編寫測試
    12.37  紅綠重構
    12.38  讓測試通過
    12.39  增加紅色測試
    12.40  最後的TDD迭代
    小結
結語
附錄A  Scala速查表
附錄B  函數式重點

同類熱銷排行榜

最近瀏覽的商品

函數式編程圖解