2011年05月_心想才事成

翻译 7.2 平面文档的表示

7.2 平面文档的表示在这一章中，我们将要开发一个用于查看文档的应用程序。我们开始设计文档的表示形式，适合于绘制在屏幕上。在这种表示中，文档就是元素的列表，有一些内容（可以是文本，也可以是图像），和指定的边框，其中的内容被绘制。在图7.1中，你可以看到一个文档的示例，有三个突出显示的元素。让我们看一下在 F# 表示文档的数据结构。清单 7.4 介绍了新的差别联合，表示

2011-05-30 11:28:00 512

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

7.1.2 C# 中的函数式数据结构我们已经在 C# 中实现了几个函数式的不可变数据类型，比如 FuncList 或元组。在 C# 中，我们会通过写一类特定的方式实现。最重要的是，所有属性必须是不可变的。这可以通过使用只读字段，或者通过声明私有的 setter 属性，只在类的构造函数中设置。在清单 7.3 中，我们使用第一种方法来实现似于类清单 7.1 中的 Rect 类型的类。

2011-05-28 15:32:00 676

翻译 7.1.1 使用 F# 记录类型

7.1.1 使用 F# 记录类型记录是带标记元组（labeled tuples）。它他们将多个不同的元素存储在一个值中；此外，每个元素都有一个可以用来访问它的名字。在 F# 中，元素的名字叫字段（fields）。这在很多方面类似于 C 的记录或结构构造，或者 C# 中的匿名类型。与匿名类型不同，记录必须事先声明。类似于匿名类型，记录，在其基本的形式中，包含唯一属性保存数据；清单

2011-05-27 10:53:00 696

翻译 7.1 函数式数据结构

7.1 函数式数据结构在函数编程中，程序操作的数据始终存储在数据结构中。数据结构和对象之间的区别是，数据结构公开数据使用的表示形式（如名字所暗示) 的结构。知道数据的结构便于写代码来处理它，我们会在第 9 章中看到，F# 还我们一种方式来封装结构，就像在面向对象中，当我们想从库中导出 F# 数据结构，或者使其在 C# 中可用。正如我们在第 2 章谈到函数概念时所说的，这些数据结

2011-05-26 14:28:00 986

翻译 7 以数据为中心的程序设计

7 以数据为中心的程序设计本章介绍■ 表示和处理文档■ 设计不可变数据结构■ 数据表示形式之间的转换■ 使用记录和递归差别联合在设计函数式程序时，首先考虑程序处理的数据。由于重要的程序都使用数据，因此，在应用程序设计中，这一阶段是极为重要的。在函数语言中，实现程序时，我们也从在代码中会用到的数据结构开始，然后，第二步，写操作处理数据。这是不同

2011-05-26 11:31:00 833

翻译 6.9 第六章小结

6.9 第六章小结这一章连同第 5 章一起，讨论了函数值。正如我们在前一章看到的，对于控制程序流，值是重要的，我们能够以函数方式写代码，组合函数，取值作为参数，并返回值作为结果。在这一章中，我们看到更简便方法处理值的。不直接使用值的结构，使用一组在 F# 库中定义的高阶函数值。我们已经看它们是如何实现的，以及如何为我们自己的类型，以实现类似的功能。特别是，我们讨论了函

2011-05-24 19:00:00 407

翻译 6.8.2 列表的绑定操作

6.8.2 列表的绑定操作我们只讨论了选项值的绑定操作，但正如我们将在第 12 章看到的，它通常是非常重要的函数式操作。清单 6.26 显示了选项值绑定操作的类型签名，以及如果我们定义列表的绑定操作，它看起来又会怎样。 Listing 6.26 Signatures of bind operations (F#) Option.bind : ('a -> 'b o

2011-05-24 14:32:00 503

翻译 6.8.1 映射、筛选和折叠

6.8.1 映射、筛选和折叠映射、筛选和折叠是函数编程中最常见的操作。在处理函数式列表时，我们已经用到过，但它们也支持所有其他集合类型（我们将在第 10 和 12 章讨论其中一些) 。这些操作并不限于集合，所有的操作都可用于处理选项类型。清单 6.25 显示了映射、筛选和折叠函数的几个签名类型。该列表包括了 Option.filter 和 Option.fold 函

2011-05-24 10:15:00 512

翻译 6.8 通用处理语言

6.8 通用处理语言如经过这一章的课程，我们已经看到几个递归模式，比如一个叫映射的操作，既可用于选项的值，也可用于列表。我们还用它处理元组，并实现了 mapFirst 和 mapSecond 的函数。许多不同的值共享一组相似的处理函数，因此，把这些操作认为当作一种通用语言是意义的。但是，操作的名称可以随值而不同：类型签名中的相似之处往往要比名称中的相似之处有更好的线索

2011-05-23 16:40:00 389

翻译 6.7.3 实现列表函数

6.7.3 实现列表函数不显示如何实现刚才我们看到的筛选和映射函数，先来看看从第 3 章开始创建的函数。因为，所有列表处理函数都有类似的结构，你在看下面的示例后，可以能够实现其他任何的函数。在第 3 章，我们写了一个函数，它可以列表中的所有元素求和或求积。后来，我们就意识到它是比首次出现时更有用：我们看到，它也能用来查找最小或最大元素。那时，我们没有讨论过泛型，因此，

2011-05-23 16:23:00 443

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

6.7.2 理解列表函数的类型签名我前面提到过，我们已用函数来筛选和映射列表，但使用都很直观。在本节中，我们将看看它们的类型签名，会看到，我们可以推断一个高阶函数只使用此信息做什么。当然，在一般情况下，你不能通过看函数的类型，就知道它能做什么，但对于泛型和高阶函数，例如那些用来处理列表的函数，通常是可能的。如我们前面所见的，处理泛型值的函数则不能单独处理值太多，因为，

2011-05-20 15:30:00 504

翻译 6.7.1 F# 中实现列表

6.7.1 F# 中实现列表虽然我们已经处理过 F# 中的列表，还在 C# 中实现了相同功能，但还没有探索在 F# 中如何实现列表类型。当我们前面讨论列表时，看到列表既可以表示为零（nil）值（空列表），也可以表示成 cons cell，包含一个元素和对列表中的其余部分的引用。现在，如果我们看看上一章中的值的图库，这与带有两个选项的可选值完全一样。有一点稍微不同，列

2011-05-19 11:38:00 431

翻译 6.6.2 自动泛型化（automatic generalization）

6.6.2 自动泛型化（automatic generalization）在这一章中，我们已经实现了几个 F# 中的高阶函数，看到了几个在 F# 和 C# 中并排的实现。有关 F# 实现的有趣事实是，我们根本不需要指定类型。这是由于自动泛型化（automatic generalization），它用在推断函数声明的类型。我们将用 Option.bind 函数的实现作为示例，介绍这

2011-05-19 09:32:00 424

翻译 6.7.1 F# 中实现列表

6.7.1 F# 中实现列表虽然我们已经处理过 F# 中的列表，还在 C# 中实现了相同功能，但还没有探索在 F# 中如何实现列表类型。当我们前面讨论列表时，看到列表既可以表示为零（nil）值（空列表），也可以表示成 cons cell，包含一个元素和对列表中的其余部分的引用。现在，如果我们看看上一章中的值的图库，这与带有两个选项的可选值完全一样。有一点稍微不同，列

2011-05-19 09:30:00 479

翻译 6.7 处理列表

6.7 处理列表在第 3 章，我们讨论过列表，学会了如何显式使用递归和模式匹配来处理列表。还在 C# 中实现了一个函数式列表类型。在第 4 章的示例应用程序中，以这种方式，使用列表，但是要注意，显式写列表处理并不是很实用的。这是这一章用到递归模式，因此，你可能已经知道我们下一步要说什么了。在每种情况下，不显式使用模式匹配，我们可以使用高阶函数来处理列表。我们已经看到一

2011-05-19 09:23:00 386

翻译 6.6.1 F# 中函数调用的类型推断

6.6.1 F# 中函数调用的类型推断虽然，在 F# 中，使用尖括号指定类型参数值，是可能的，与在 C# 中的方式相同，但这种方法很少使用。原因是，当编译器无法推断出所有的信息，需要从程序员的一些帮助时，我们可以将类型批注添加到特定的，需要更多的信息的位置。让我们用一个示例来演示： > Option.map (fun dt -> dt.Year) (Some(DateTi

2011-05-18 09:26:00 478

翻译 6.6 类型推断

6.6 类型推断我们曾经讨论过值的类型推断，看到了在 C# 3.0 中用 var 关键字，在 F#中用 let 绑定。我们将从本节开始，另一个方面是由 C# 和 F# 共享的。当在 C# 中调用泛型方法时，如 Option.Some（清单 5.9）或 Option.Map（清单 6.13），可以显式指定类型参数值，像这样： var dt = Option.Some(Dat

2011-05-18 08:40:00 478

翻译 6.5.2 C# 中的函数组合

6.5.2 C# 中的函数组合 C# 中的函数组合是可能的，但它的使用非常有限。这是部分是由于在 C# 中，偏应用不能很容易使用，但更重要的是，因为大多数操作是写为成员，而不是函数。我们至少可以在 C# 中演示同样的想法。清单 6.18 显示了 Compose 方法的实现，以及使用它的示例。 Listing 6.18 Implementing and using the C

2011-05-17 14:48:00 533

翻译 6.5.1 函数组合

6.5.1 函数组合处理函数最重要的操作，就是组合。让我们首先看一个示例，这是非常有用的。我们将使用这个示例，用元组存储（城市的）名字和人口。在清单 6.16 中，我们创建一个函数，根据人口的规模，确定是城市、镇，还是村。还通过确定存储在列表中的几个地方的状态测试它。 Listing 6.16 Working with city information (F# Inter

2011-05-17 11:37:00 599

翻译 6.5 处理函数

6.5 处理函数目前为止，我们在这一章中讨论到的所有高阶函数都有类似结构。它们有两个参数：一个是要处理的值，另一个是函数，指定如何处理这个值。在处理函数时，值参数也可以是一个函数，所以，我们的高阶函数，将取两个函数作为参数值。

2011-05-16 11:34:00 365

翻译 5.4.4 实现选项类型的操作

5.4.4 实现选项类型的操作绑定和映射的实现有类似的结构，因为，两者都是高阶函数，模式匹配依据一个选项值。我们来看一看 F# 和 C# 的实现，是在 C# 中编码函数概念的好示例。让我们从清单 6.14 开始，显示了映射操作的实现。 Listing 6.14 Implementing the map operation in F# and C#F# Inte

2011-05-16 11:12:00 491

翻译 6.4.3 分步分析这个示例

6.4.3 分步分析这个示例这像这样自信地使用高阶函数，可能需要一些时间，尤其是当它们嵌套时。我们将研究来自前面清单中的代码，通过跟踪来看它是如何工作的，如何通过几个样本输入运行的。从抽象的问题"此代码在一般情况下做什么？"，到具体的问题"此代码在特定情况下做什么？"，通常可以帮助澄清事宜。让我们看看会发生什么情况，如果我们输入一个无效的值，作为第一个输入。在这种情况

2011-05-13 09:30:00 410

翻译 6.4.2 使用 bind 函数

6.4.2 使用 bind 函数下一步，我们想消除外层的模式匹配。这样做，使用 Option.map 是不可能的，因为，该函数总是输入值 None 转换到输出值 None，输入值 Some 转换到输出到携带另一个值的 Some。在外层的模式匹配中，我们要做的事情很不一样。即使输入值是 Some，仍可能返回 None，如果读第二个输入失败。这意味着，我们指定为参数值的 lambd

2011-05-12 15:55:00 375

翻译 6.4.1 使用 map 函数

6.4.1 使用 map 函数我们将使用的两个操作，已在 F# 库中可用了，因此，我们首先看一下如何使用它们。稍后，我们将讨论它们的实现，以及如何从 C# 中使用它们。正如我们已经看到的，要了解函数在 F# 做什么的最好方法，通常是了解它的类型签名。让我们来看一下 Option.map： > Option.map;; val it : (('a -> 'b) -> '

2011-05-12 09:14:00 482

翻译 6.4 处理选项类型

6.4 处理选项类型 F# 中，最重要的可选值之一就是选项（option）类型。回顾一下我们的在前面的章节中看到，它给了我们一种安全的方法来表示值可能会缺失的事实。此安全性意味着，我们不能轻松地写代码，可能假定值是存在的，也可能当这个选项类型表示缺失值时，将失败。相反，我们必须使用模式匹配，为这两种情况而写代码。在这一节中，我们将学习两个有用的函数，处理选项类型。注意

2011-05-11 16:17:00 440

翻译 6.3.2 在 C# 中处理计划

6.3.2 在 C# 中处理计划在 C# 中，我们将构建 MapSchedule 方法，类似于 F# 中的 mapSchedule 函数。再次，这将有两个参数：一个用于计算新日期的函数，和原先计划。因为我们将在 C# 中处理可选值，使用 switch 块和 Tag 属性，正如在第 5 章看到的一样。清单6 .9显示了完整的实现。 Listing 6.9 Map oper

2011-05-11 14:50:00 487

翻译 6.3.1 处理计划列表

6.3.1 处理计划列表在前面的示例中，我们使用了一个命令式的 for 循环，因为，我们想要打印新的计划。如果想要创建一个列表，包含新的计划，可以使用 List.map 函数，写成这样： let newSchedules = List.map (fun s –> s |> mapSchedule (fun d -> d.AddDays(7.0))

2011-05-11 09:12:00 439

翻译 6.3 处理计划

6.3 处理计划在本节中，我们将把上一节的技术应用到可选为值。在处理元组时，我们发现写函数，有助于处理元组中的一个元素。同样，处理可选值时，需要高阶函数，在一个或多个可选值上执行某种操作。我们接着上一章的示例，我们从计划类型开始，然后，看一下选项类型。在前面的章节中，我们实施了一个类型，表示事件的计划。在 F# 中，它是叫 Schedule（计划）的差别联合，可以包含

2011-05-10 16:00:00 387

翻译 6.2.2 在 C# 中处理元组的方法

6.2.2 在 C# 中处理元组的方法在本节中，我们将处理来自第 3 章的泛型 Tuple 类，添加类似于我们刚才在 F# 中看到的功能。清单 6.6 显示了高阶函数 mapFirst 和 mapSecond 的 C# 版本。 Listing 6.6 Extension methods for working with tuples (C#) public sta

2011-05-10 10:37:00 1102

翻译 6.2.1 使用函数处理元组

6.2.1 使用函数处理元组在第 3 章，我们用元组来表示城市和人口。当我们想要增加人口时，不得不写点东西，像这样： let (name, population) = oldPrague let newPrague = (name, population + 13195) 这很清晰，但有点罗唆。第一行分解元组，第二行对第二个元素执行计算，然后，生成新的

2011-05-09 21:13:00 437

翻译 6.2.1 使用函数处理元组

6.2.1 使用函数处理元组在第 3 章，我们用元组来表示城市和人口。当我们想要增加人口时，不得不写点东西，像这样： let (name, population) = oldPrague let newPrague = (name, population + 13195) 这很清晰，但有点罗唆。第一行分解元组，第二行对第二个元素执行计算，然后，生成新的

2011-05-09 21:13:00 356

翻译 6.2 处理元组

6.2 处理元组我们从第 3 章第一个函数代码起，一直以来都在使用元组，已经相当熟悉了。但是，我们还没看看如何使用高阶函数来处理元组。元组是很简单的，因此，可以经常直接使用它们，但在某些情况下，代码可能并不精简。对于探索高阶函数，元组是一个好的起点，因为，它们是那么简单。我们在这里看到的原则也适用于其他类型。

2011-05-09 14:32:00 374

翻译 6.1.2 自定义运算符

6.1.2 自定义运算符定义自定义的运算符的方式类似于函数，使用 let 绑定。它们可以使用任何字符，可以是通常的 F# 数学运算符（+/-* Listing 6.2 Working with strings using a custom operator (F# Interactive) > let (+>) a b = a + "/n>> " + b;;

2011-05-09 14:20:00 1308

翻译 6.1.1 写 F# 中的泛型函数

6.1.1 写 F# 中的泛型函数在第 5 章，我们看到了一个简单的泛型函数，它只使用单个参数值，是一个泛型选项类型。清单 6.1 显示 CondPrint 方法的 F# 实现，来自"在函数式编程和面向对象中的泛型代码"侧边栏。它有三个参数值：一个值、一个函数，用于测试是否应打印这个值，还有一个函数，用于设置格式化这个值。 Listing 6.1 Generic fun

2011-05-06 14:47:00 654

翻译 6.1 泛型高阶函数

6.1 泛型高阶函数高阶函数是写泛型函数代码的一种方法，这意味着，相同的代码可重复使用于许多类似但不同的目的。这是现代编程的一个关键，因为，它允许我们写更少的代码行，通过分解出计算的共同部分。在函数式编程和面向对象中的泛型代码当编写泛型代码时，通常要对我们所获得的值执行某个操作，但是，由于代码应该是泛型的，我们不想太多地限制值的类型，想要允许代码进一步

2011-05-05 15:37:00 518

翻译 6 使用高阶函数处理值

6 使用高阶函数处理值本章介绍■ 使用元组选项和列表■ 为类型写高阶函数■ 在 F# 中使用自动泛型化■ 组合函数与偏应用在前面的章节中，我们介绍了最常用的函数值。你已经看到这些值如何被构造，以及如何使用模式匹配来处理它们。像这样显式表示所有逻辑可能是冗长乏味的，特别是如果这个类型具有复杂的结构。由一个或几个简单值组成的值的类型包括前一

2011-05-05 14:57:00 511

5.6 第五章小结在这一章中，我们讨论了值，讨论了有关函数的详细信息，突出了一个事实，在 F# 中，函数就是值！我们看到几个创建不同的值和对应组合类型的方法。从讨论元组开始，给我们一个存储多个值为一个的方法。接下来，我们讨论了差别联合，使我们能够表示包含多种选项的值。声明差别联合时，指定哪些情况，然后，值可以是声明的选项之一。还讨论了泛型类型，类似于 C# 中的泛型类。用来声明的类型，可用于携带不同的值，这使代码更通用和可重用。我们还讨论了这些类型背后的理论，看看它们在 F#

2011-05-05 10:50:00 276

翻译 5.5.3 多参数值的函数

5.5.3 多参数值的函数让我们回顾一下，写一个函数，能有哪些选项。在 F# 中，当写具有多个参数值的函数时，我们可以使用元组。我们下一个示例显示了一个函数，以这种风格加两个整数。我们将使用 lambda 函数的语法，但在 F# 中，使用简单的 let 绑定，也可以得到相同的结果： > let add = fun (a, b) -> a + b;; val add : int * int -> int 通过看类型签名，可以看到，该函数取一个参数值，这是一个元组

2011-05-04 17:34:00 542

翻译 5.5.2 函数类型

5.5.2 函数类型我们已经看到，在 F# 中，函数值的类型写成箭头符号，这是在很多方面类似于建造的元组的方式。早些时候，我们看到，可以从其他简单的类型，使用带类星号（int * string）的类型构造函数，构造元组类型。函数类型以类似方式构造，只是使用函数类型构造函数（int -> string）。在数学意义上，函数就是关系，为每个可能的输入指定返回值，而不是指定大量的这种关系的所有组合，只指定计算结果的代码，使用 lambda 函数。在 C# 中，也可以看到这种相似性

2011-05-03 20:24:00 350

翻译 5.5.1 Lambda 函数

5.5.1 Lambda 函数在 F# 中，lambda 函数创建的函数，与一般使用 let 绑定声明的相同。在 C# 中，没有任何内置的函数概念，所以，我们既可以使用方法，也可以使用委托。写的 lambda 函数，被转换为委托或表达式树（在“C# 中从委托到函数"边栏中，可以找到有关表达式树的详细信息），但是，在 C# 中，不能使用 lambda 函数声明普通方法。委托可以像任何其他值一样使用，所以，可以把它们作为参数值传递给其他的方法，这意味着，我们可以用它们在 C# 中写高阶函

2011-05-03 12:21:00 641

SQL.Server.2012.Integration.Services-2

SQL.Server.2012.Integration.Services

SQL.Server.2012.Administration-2

SQL.Server.2012.Administration

jQuery.1.4.Reference.Guide

空空如也