有用函数编程

《序》

感谢

关于本书

关于封面

第一部分 学习函数式思维

  第一章 不同的思维

    1.1 什么是函数式编程？

    1.2 通往有用函数编程之路

    1.3 用函数式编程提高生产力

        1.3.1 函数范式

        1.3.2 声明式编程风格

        1.3.3 了解程序的执行

        1.3.4 设计并发友好的应用程序

        1.3.5 函数风格怎样形成代码

    1.4 函数式编程演示样例

        1.4.1 用声明式风格表达意图

            1.4.1.1 用 LINQ 处理数据

            1.4.1.2 用 XAML 描写叙述用户界面

            1.4.1.3 声明式函数动画

        1.4.2 理解使用不可变性的代码

             1.4.2.1 阅读函数式程序

        1.4.3 编写有效的并行程序

            1.4.3.1 并行化不可变程序

            1.4.3.2 使用 PLINQ 的声明式并行

    1.5 F# 简单介绍

        1.5.1 用 F# 写 Hello world

        1.5.2 从简单到有用

            1.5.2.1 从简单開始

            1.5.2.2 到稳健结束

    1.6 小结

   第二章 函数编程的核心概念

    2.1 函数编程的基础

    2.2 函数程序的计算       2.2.1 使用不可变值

       2.2.2 使用不可变数据结构

       2.2.3 用递归改变程序状态

       2.2.4 用表达式取代语句

       2.2.5 计算 （Computation by calculation）

    2.3 编写声明式代码

        2.3.1 函数也是值

        2.3.2 高阶函数（Higher-order functions）

            2.3.2.1 使用高阶函数扩展词汇

            2.3.2.2 面向语言编程（Language-oriented programming）

    2.4 函数式类型和值

        2.4.1 C# 和 F# 中的类型判断

        2.4.2 区别联合类型（discriminated union type）

        2.4.3 模式匹配（Pattern matching）

        2.4.4 编译时检查程序

            2.4.4.1 度量单位（UNITS OF MEASURE）

    2.5 第二章小结

    第三章 F# 和 C# 中元组、列表和函数

    3.1 值和函数的声明

        3.1.1 值的声明和作用域

        3.1.2 函数的声明

            3.1.2.1 函数签名（FUNCTION SIGNATURES）

            3.1.2.2 嵌套函数声明（NESTED FUNCTION DECLARATIONS）

        3.1.3 声明可变值

    3.2 使用不可变数据结构

        3.2.1元组类型（tuple）

            3.2.1.1 在 F# 中使用元组

            3.2.1.2 在 C# 中使用元组

        3.2.2 用 C# 实现元组类型

            3.2.2.1 更好地判断 C# 元组类型

        3.2.3 计算元组

        3.2.4 模式匹配元组

    3.3 列表和递归

        3.3.1 递归计算

        3.3.2 函数式列表

            3.3.2.1 用模式匹配分解列表

        3.3.3 C# 中的函数式列表

        3.3.4 处理函数式列表

            3.3.4.1 用 C# 求列表中数字的和

            3.3.4.2用 F# 求列表中数字的和

    3.4 函数也是值

        3.4.1 处理数字列表

            3.4.1.1 在 C# 中传递函数作为參数值

            3.4.1.2 在 F# 中传递函数作为參数值

        3.4.2 參数化函数的优点

    3.5 第三章小结

    第四章 通过演示样例探索 F# 和 .NET 库

    4.1 用 F# 绘制饼图

    4.2 用 FSI 编写和測试代码

        4.2.1 载入和解析数据

        4.2.2 计算数据

    4.3 创建控制台应用程序

    4.4 创建 Windows Forms 应用程序

        4.4.1 创建用户界面

        4.4.2 绘制图形

            4.4.2.1 创建随机颜色的画笔

            4.4.2.2 绘制饼图部分

            4.4.2.3 用函数画图

            4.4.2.4 绘制整个图表

            4.4.2.5 加入文本标签

        4.4.3 创建 Windows 应用程序

    4.5 第四章小结

    

第二部分 函数技术的基础

    第五章 局部使用函数值

    5.1 什么是值？

        5.1.1 基本类型、值类型和对象

        5.1.2 认识值和数据

    5.2 多值（Multiple values）

        5.2.1 F# 和 C# 中的多值

            5.2.1.1 用元组取代 out 參数

        5.2.2 元组类型和值的构造函数

        5.2.3 组合使用元组

            5.2.3.1 避免复杂的元组

    5.3 可选值（Alternative values）

        5.3.1 F# 中的区别联合（discriminated unions）

        5.3.2 使用可选值

            5.3.2.1 用 F# 匹配区别联合

            5.3.2.2 用 C# 模拟区别联合

        5.3.3 加入类型还是函数

        5.3.4 F# 中的选项（option）类型

            5.3.4.1 实现 F# 中简单的选项类型

    5.4 泛型值（Generic values）

        5.4.1 在 C# 中实现选项类型

        5.4.2 F# 中的泛型选项类型

        5.4.3 值的类型判断

            5.4.3.1 C# 3.0 中的类型判断

            5.4.3.2 F# 中的类型判断

        5.4.4 写泛型函数

    5.5 函数值

        5.5.1 Lambda 函数

            5.5.1.1 类型批注、动作和语句块（TYPE ANNOTATIONS, ACTIONS, AND STATEMENT BLOCKS）

        5.5.2 函数类型

            5.5.2.1 函数作为參数值和返回值

        5.5.3 多參数函数

            5.5.3.1 散函数应用（PARTIAL FUNCTION APPLICATION）

    5.6 第五章小结

    第六章 使用高阶函数处理值

    6.1 泛型高阶函数

        6.1.1 F# 中的泛型函数

        6.1.2 自己定义运算符

            6.1.2.1 在 C# 中模拟自己定义运算符

           6.1.2.2 F# 的管道运算符

    6.2 处理元组

        6.2.1 使用函数处理元组

        6.2.2 C# 中处理元组的方法

    6.3 处理计划

        6.3.1 处理计划列表

        6.3.2 在 C# 中处理计划

    6.4 处理选项类型

        6.4.1 使用 map 函数

        6.4.2 使用 bind 函数

        6.4.3 分步分析（Evaluating）演示样例

        6.4.4 实现选项类型的操作

           6.4.4.1 在 C#中使用选项类型

    6.5 使用函数

        6.5.1 函数组合

        6.5.2 C# 中的函数组合

    6.6 类型判断

        6.6.1 F# 中函数调用的类型判断

        6.6.2 自己主动泛型化（automatic generalization）

    6.7 处理列表

        6.7.1 用F# 实现列表

        6.7.2 理解列表函数的类型签名

            6.7.2.1 处理列表

        6.7.3 实现列表函数

            6.7.3.1 在 C# 中实现 fold

    6.8 通用处理语言

        6.8.1 映射、筛选和折叠（Mapping, filtering, and folding）

        6.8.2 列表的绑定操作

    6.9 第六章小结

    第七章 以数据为中心的程序设计

    7.1 函数式数据结构

        7.1.1 使用 F# 记录类型

            7.1.1.1 处理记录

        7.1.2 C# 中的函数式数据结构

    7.2 平面文档的表示

        7.2.1 绘制元素

        7.2.2 在窗口上显示画图

    7.3 表示结构化文档

        7.3.1 转换表示

        7.3.2 用 XML 表示文档

    7.4 写操作

        7.4.1 用映射操作进行更新

        7.4.2 使用聚合操作进行计算

    7.5 面向对象的表示方法

        7.5.1 用结构模式表示数据

            7.5.1.1复合设计模式（THE COMPOSITE DESIGN PATTERN）

            7.5.1.2 装饰设计模式（THE DECORATOR DESIGN PATTERN）

    第八章 以行为为中心的程序设计

    8.1 使用行为集合

        8.1.1 把行为表示为对象

        8.1.2 在 C# 中把行为表示成函数

        8.1.3 在 C# 中使用函数集合

        8.1.4 在 F# 中使用函数列表

    8.2 用于处理函数的习惯用语

        8.2.1 策略设计模式（The strategy design pattern）

        8.2.2 命令设计模式（The command design pattern）

            8.2.2.1 在 C＃ 中使用命令模式捕获状态

        8.2.3 在 F# 使用闭包捕获状态

            8.2.3.1 可变状态使用引用单元

            8.2.3.2 在闭包中捕捉引用单元

    8.3 使用组合行为

        8.3.1 函数的记录

        8.3.2 构建组合行为

        8.3.3 F# 代码的进一步演变

            8.3.3.1 C# 中的组合行为

    8.4 组合数据和行为

        8.4.1 决策树（Decision trees）

        8.4.2 F# 决策树

        8.4.3 C# 决策树

            8.4.3.1 模板方法模式

            8.4.3.2 函数式实现

    8.5 第八章小结

    第三部分 F# 高级编程技术

    第九章 把值转变成 F# 带成员的对象类型

    9.1 改进以数据为中心的应用程序

        9.1.1 加入成员到 F# 类型

        9.1.2 使用类型扩展追加成员

    9.2 改进以行为为中心的应用程序

        9.2.1 使用保存的函数记录

        9.2.2 使用接口对象类型

    9.3 使用 .NET 接口

        9.3.1 使用 .NET 集合

        9.3.2 用 IDisposable 接口清理资源

            9.3.2.1 用keyword use 编程

    9.4 详细的对象类型

        9.4.1 函数式和命令式类

        9.4.2 实现接口和类型转换

            9.4.2.1 在 F# 中实现接口

            9.4.2.2 F# 中的向上转换和向下转换（UPCASTS AND DOWNCASTS）

    9.5 在 C# 中使用 F# 库

        9.5.1 处理记录和成员

        9.5.2 使用值和托付

    9.6 第九章小结

    第十章 数据结构的效率

    10.1 优化函数

        10.1.1避免尾递归的堆栈溢出

            10.1.1.1 使用累加器參数

        10.1.2 使用记忆化缓存结果

            10.1.2.1 C# 和 F# 中可重用的记忆化

    10.2 处理大集合

        10.2.1 用尾递归避免栈溢出（续!）

        10.2.2 高效处理列表

            10.2.2.1 加入元素到列表

        10.2.3 处理数组

            10.2.3.1 以函数方式使用数组

            10.2.3.2 在 C# 中以函数风格使用数组

    10.3 连续（continuations）

        10.3.1 树处理的难点

        10.3.2 利用连续的代码

            10.3.2.1 使用连续处理树

    10.4 第十章小结

    第十一章 重构和測试函数式程序

    11.1 重构函数式程序

    11.1.1 重用常见的代码块

    11.1.2 跟踪依赖性和副作用

    11.1.2.1 使用可变数据结构

    11.1.2.2 使用不可变数据结构

    11.2 測试函数式代码

    11.2.1 从交互式控制台到单元測试

    11.2.1.1 在 F# 交互环境中測试程序

    11.2.1.2 在 F# 中写单元測试

    11.2.2 測试结构相等

    11.2.2.1 结构相等和比較

    11.2.2.2 測试列表

    强大的复制工具 Robocopy

    system 执行 cmd

    11.2.3 測试组合函数

    11.3 重构计算顺序

    安装 WIn8.1 创建用户问题

    11.3.1 不同的计算策略

    11.3.1.1 C# 和 F# 中的提前计算

    11.3.1.2 Haskell 的延迟计算策略

    11.3.2计算策略的比較

    11.3.3 用函数模拟延迟计算

    11.3.4 F# 中的延迟值

    11.3.4.1 实现或和延迟或

    11.3.5 为 C# 实现延迟值

    11.4 有用延迟值

    11.4.1 无穷列表

    11.4.2 在照片浏览器中缓存值

    11.4.2.1 使用延迟值进行缓存

    11.4.2.2 实现用户界面

    11.5 第十五章小结

    第十二章 序列表达式和可选工作流

    12.1 生成序列

    12.1.1 使用高阶函数

    12.1.2 在 C# 中使用迭代器

    12.1.3 使用 F# 序列表达式

    12.1.3.1 写序列表达式

    12.1.3.2 组合序列表达式

    12.2 掌握序列表达式

    12.2.1 递归的序列表达式

    12.2.2 无穷序列

    12.3 处理序列

    找不到符号

    12.3.1 用迭代器转换序列

    12.3.2 筛选和映射

    12.3.2.1 使用高阶函数

    12.3.2.2 使用查询和序列表达式

    12.3.3 平面映射（flattening projection）

    12.3.3.1 序列表达式中的平面映射

    12.3.3.2 直接使用平面映射

    12.3.3.3 在 C# 中使用平面映射

    把 Win 8.1 升级成 Windows 2012 R2

    12.4 可选工作流（alternative workflows）

    12.4.1 自己定义查询表达式

    12.4.2 自己定义 F# 语言

    12.5 自己定义计算的第一步

    12.5.1 声明计算类型

    12.5.2 写计算

    12.5.3 在 F# 中实现计算生成器

    12.5.4 在 C# 中实现查询操作

    不急不躁修硬盘

    12.6 实现选项的计算表达式

    12.7 给计算添加日志记录

    12.7.1 创建日志记录计算

    12.7.2 创建日志记录计算

    12.7.3 使用计算表达式进行重构

    12.8 第十二章小结