精通F# 3.0：数据驱动的函数式编程实践指南

5星 · 超过95%的资源需积分: 10 186 浏览量更新于2024-07-26 1 收藏 15.59MB PDF 举报

"Expert F# 3rd Edition 是一本关于F#编程语言的专业书籍，旨在帮助专业开发者掌握这种强大而优雅的函数式编程语言，将其与.NET框架相结合，以实现无与伦比的开发效率和程序清晰度。该PDF版本为高清英文原版，大小比3.29M的版本更清晰，方便阅读。" 本书内容涵盖了F# 3.0的各个方面，从基础到高级主题，为读者提供了一个全面的学习路径。以下是书中的主要内容概览： 1. **序言和前言**：包括作者简介、技术审阅者介绍以及致谢部分，为读者提供了书籍的背景信息和创作团队的贡献。 2. **第一章：介绍**：开篇引导读者进入F#的世界，解释了为什么F#是一种强大的编程语言，并概述了其在.NET生态系统中的地位。 3. **第二章：你的第一个F#程序**：介绍了如何开始编写F#代码，帮助初学者快速上手。 4. **第三章：介绍函数式编程**：深入讲解函数式编程的核心概念，如高阶函数、不可变数据和递归。 5. **第四章：介绍命令式编程**：讨论F#中的命令式编程风格，包括副作用和状态管理。 6. **第五章：理解函数式编程中的类型**：详细阐述F#的类型系统，包括静态类型、模式匹配和类型推断。 7. **第六章：面向对象编程**：展示了F#如何支持面向对象编程，包括类、接口和继承。 8. **第七章：封装和组织代码**：探讨如何通过模块、命名空间和库来有效地组织和管理代码。 9. **第八章：处理文本数据**：讲解处理字符串和文本文件的方法，包括正则表达式和文本解析。 10. **第九章：操作序列和结构化数据**：介绍序列的概念，如列表和数组，以及处理结构化数据的技巧。 11. **第十章：数值计算和图表**：探讨科学计算和可视化，包括数学运算和图表生成。 12. **第十一章：反应式、异步和并行编程**：讲解如何利用F#进行反应式编程、异步操作和并行计算。 13. **第十二章：符号编程与结构化数据**：介绍使用符号和抽象语法树进行高级编程的方法。 14. **第十三章：集成外部数据和服务**：涵盖如何与数据库、Web服务和其他外部资源进行交互。 15. **第十四章：构建智能Web应用**：教授如何使用F#开发高效、响应式的Web应用程序。 16. **第十五章：构建移动Web应用**：讨论移动设备上的Web应用开发，可能涉及跨平台解决方案。 17. **第十六章：可视化和图形用户界面**：介绍创建图形界面和数据可视化的方法。 18. **第十七章：语言和工具**：可能涵盖F#的高级特性，以及相关的开发工具和调试技巧。通过这本书，读者将能够深入了解F# 3.0的强大功能，学习如何利用其函数式编程特性来提高代码质量、可读性和维护性，并掌握在实际项目中应用F#的技巧。无论是初学者还是经验丰富的开发者，都能从中受益匪浅。

chapter 2 n Your FIrst F# program – gettIng started WIth F#

and

let badDeﬁnition2 = badDeﬁnition2 + 1

gives

let badDeﬁnition2 = badDeﬁnition2 + 1

error FS0039: The value or constructor 'badDeﬁnition2' is not deﬁned

Within function deﬁnitions, you can outscope values by declaring another value of the same name. For

example, the following function computes (n*n*n*n)+2:

let powerOfFourPlusTwo n =

let n = n * n

let n = n + 2

This code is equivalent to:

let powerOfFourPlusTwo n =

let n1 = n * n

let n2 = n1 * n1

let n3 = n2 + 2

Outscoping a value doesn’t change the original value; it just means that the name of the value is no

longer accessible from the current scope.

Because let bindings are simply a kind of expression, you can use them in a nested fashion. For

example:

let powerOfFourPlusTwoTimesSix n =

let n3 =

let n1 = n * n

let n2 = n1 * n1

n2 + 2

let n4 = n3 * 6

Here, n1 and n2 are values deﬁned locally by let bindings within the expression that deﬁnes n3. These

local values aren’t available for use outside their scope. For example, this code gives an error:

let invalidFunction n =

let n3 =

let n1 = n + n

let n2 = n1 * n1

n1 * n2

let n4 = n1 + n2 + n3 // Error! n3 is in scope, but n1 and n2 are not!

chapter 2 n Your FIrst F# program – gettIng started WIth F#

Local scoping is used for many purposes in F# programming, especially to hide implementation

details that you don’t want revealed outside your functions or other objects. Chapter 7 covers this topic in

more detail.

Using Data Structures

The next portion of the code is:

let wordCount (text:string) =

let words = splitAtSpaces text

let wordSet = Set.ofList words

...

This gives you your ﬁrst taste of using data structures from F# code. The last of these lines lies at the

heart of the computation performed by wordCount. It uses the function Set.ofList from the F# library to

convert the given words to a concrete data structure that is, in effect, much like the mathematical notion

of a set, although internally, it’s implemented using a data structure based on trees. You can see the results

of converting data to a set by using F# Interactive:

> Set.ofList ["b"; "a"; "b"; "b"; "c" ];;

val it : Set<string> = set [ "a"; "b"; "c" ]

> Set.toList (Set.ofList ["abc"; "ABC"]);;

val it : string list = ["ABC"; "abc"]

Here you can see several things:

• F# Interactive prints the contents of structured values, such as lists and sets.

• Duplicate elements are removed by the conversion.

• The elements in the set are ordered.

• The default ordering on strings used by sets is case sensitive.

The name Set references the F# module Microsoft.FSharp.Collections.Set in the F# library. This

contains operations associated with values of the Set<_> type. It’s common for types to have a separate

module that contains associated operations. All modules under the Microsoft.FSharp namespaces Core,

Collections, Text, and Control can be referenced by simple one-word preﬁxes, such as Set.ofList. Other

modules under these namespaces include List, Option, and Array.

Using Properties and the Dot-Notation

The next two lines of the wordCount function compute the result you’re after—the number of duplicate

words. This is done by using two properties, Length and Count, of the values you’ve computed:

let numWords = words.Length

let numDups = numWords - wordSet.Count

chapter 2 n Your FIrst F# program – gettIng started WIth F#

F# performs resolution on property names at compile time (or interactively when you’re using F#

Interactive, in which there is no distinction between compile time and runtime). This is done using

compile-time knowledge of the type of the expression on the left of the dot—in this case, words and

wordSet. Sometimes, a type annotation is required in your code in order to resolve the potential ambiguity

among possible property names. For example, the following code uses a type annotation to note that inp

refers to a list. This allows the F# type system to infer that Length refers to a property associated with values

of the list type:

let length (inp:'T list) = inp.Length

Here, the 'T indicates that the length function is generic; that is, it can be used with any type of list.

Chapters 3 and 5 cover generic code in more detail.

As you can see from the use of the dot-notation, F# is both a functional language and an object-

oriented language. In particular, properties are a kind of member, a general term used for any functionality

associated with a type or value. Members referenced by preﬁxing a type name are called static members,

and members associated with a particular value of a type are called instance members; in other words,

instance members are accessed through an object on the left of the dot. We discuss the distinction

between values, properties, and methods later in this chapter, and Chapter 6 discusses members in full.

n Note Type annotations can be useful documentation; when you use them, they should generally be added at

the point where a variable is declared.

Sometimes, explicitly named functions play the role of members. For example, you could write the

earlier code as:

let numWords = List.length words

let numDups = numWords - Set.count wordSet

You see both styles in F# code. Some F# libraries don’t use members at all or use them only sparingly.

Judiciously using members and properties, however, can greatly reduce the need for trivial get/set

functions in libraries, can make client code much more readable, and can allow programmers who use

environments such as Visual Studio to easily and intuitively explore the primary features of libraries they

write.

If your code doesn’t contain enough type annotations to resolve the dot-notation, you see an error

such as:

> let length inp = inp.Length;;

error FS0072: Lookup on object of indeterminate type based on information prior to this

program point. A type annotation may be needed prior to this program point to constrain the

type of the object. This may allow the lookup to be resolved. You can resolve this by adding a

type annotation as shown earlier.

Using Tuples

The ﬁnal part of the wordCount function returns the results numWords and numDups as a tuple:

chapter 2 n Your FIrst F# program – gettIng started WIth F#

> let a, b = (1, 2, 3);;

error FS0001: Type mismatch. Expecting a

'a * 'b

but given a

'a * 'b * 'c

The tuples have differing lengths of 2 and 3

Tuples are often used to return multiple values from functions, as in the wordCount example earlier.

They’re also often used for multiple arguments to functions, and frequently the tupled output of one

function becomes the tupled input of another function. This example shows a different way of writing

the showWordCount function deﬁned and used earlier:

let showResults (numWords, numDups) =

printfn "--> %d words in the text" numWords

printfn "--> %d duplicate words" numDups

let showWordCount text = showResults (wordCount text)

The function showResults accepts a pair as input, decomposed into numWords and numDups. The two

outputs of wordCount become the two inputs of showResults.

Values and Objects

In F#, everything is a value. In some other languages, everything is an object. In practice, you can use the

words largely interchangeably, although F# programmers tend to reserve object for special kinds of values:

• Values whose observable properties change as the program executes, usually

through the explicit mutation of underlying in-memory data or through external state

changes

• Values that refer to data or to a state that reveals an identity, such as a unique

integer stamp or the overall object identity, where that identity is used to distinguish

the object from otherwise identical values

• Values that can be queried to reveal additional functionality, through the use of casts,

conversions, and interfaces

F# thus supports objects, but not all values are referred to as objects. F# programming is not “object-

oriented”; rather, it uses objects where they are most useful. Chapter 4 discusses identity and mutation in

more detail.

Using Imperative Code

The showWordCount and showResults functions deﬁned in the previous section output results using a library

function called printfn:

printfn "--> %d words in the text" numWords

printfn "--> %d duplicate words" numDups

剩余615页未读，继续阅读

u010429168

粉丝: 0
资源: 1

精通F# 3.0：数据驱动的函数式编程实践指南

ExpertPDF HtmlToPdf Converter v9.5 去水印版

《Expert F#》英文原版

C#与F#编程实践 英文版PDF带书签带源码

Expert F# 3.0, 3rd Edition

Expert F#.pdf

Expert Python Programming-3rd edition (2019).pdf

Expert F#（精通F#）

F# 英文教程：Expert F#

Expert F#PDF书籍及实例源码

expert F＃book

最新资源

C#与F#编程实践英文版PDF带书签带源码