vsintegration/ProjectTemplates/TutorialProject/Template/xlf/Tutorial.fsx.zh-Hans.xlf (1,637 lines of code) (raw):
<?xml version="1.0" encoding="utf-8"?>
<xliff xmlns="urn:oasis:names:tc:xliff:document:1.2" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2" xsi:schemaLocation="urn:oasis:names:tc:xliff:document:1.2 xliff-core-1.2-transitional.xsd">
<file datatype="xml" source-language="en" target-language="zh-Hans" original="../Tutorial.fsx">
<body>
<trans-unit id="SampleHeader">
<source>This sample will guide you through elements of the F# language.</source>
<target state="translated">此示例将引导你了解 F# 语言的各个元素。</target>
<note />
</trans-unit>
<trans-unit id="Instructions-Line1">
<source>To execute the code in F# Interactive, highlight a section of code and press Alt-Enter or right-click</source>
<target state="translated">若要在 F# 交互中执行代码，请突出显示一个代码节并按 Alt-Enter 或右击</target>
<note />
</trans-unit>
<trans-unit id="Instructions-Line2">
<source>and select "Execute in Interactive". You can open the F# Interactive Window from the "View" menu.</source>
<target state="translated">并选择“在 Interactive 中执行”。 可从“视图”菜单中打开 F# 交互窗口。</target>
<note />
</trans-unit>
<trans-unit id="MoreAbout">
<source>For more about F#, see:</source>
<target state="translated">有关 F# 的详细信息，请参见:</target>
<note />
</trans-unit>
<trans-unit id="SeeDocumentaton">
<source>To see this tutorial in documentation form, see:</source>
<target state="translated">若要以文档的形式查看此教程，请参阅:</target>
<note />
</trans-unit>
<trans-unit id="LearnMoreAbout">
<source>To learn more about applied F# programming, use</source>
<target state="translated">若要了解有关已应用的 F# 编程的详细信息，请使用</target>
<note />
</trans-unit>
<trans-unit id="ToInstall-Line1">
<source>To install the Visual F# Power Tools, use</source>
<target state="translated">若要安装 Visual F# Power Tools，请使用</target>
<note />
</trans-unit>
<trans-unit id="ToInstall-Line2">
<source>'Tools' --> 'Extensions and Updates' --> `Online` and search</source>
<target state="translated">“工具”-->“扩展和更新”-->“联机”和搜索</target>
<note />
</trans-unit>
<trans-unit id="AdditionalTemplates-Line1">
<source>For additional templates to use with F#, see the 'Online Templates' in Visual Studio,</source>
<target state="translated">有关要用于 F# 的其他模板，请参见 Visual Studio 中的“联机模板”。</target>
<note />
</trans-unit>
<trans-unit id="AdditionalTemplates-Line2">
<source>'New Project' --> 'Online Templates'</source>
<target state="translated">“新建项目”-->“联机模板”</target>
<note />
</trans-unit>
<trans-unit id="SupportsComments">
<source>F# supports three kinds of comments:</source>
<target state="translated">F# 支持三种注释:</target>
<note />
</trans-unit>
<trans-unit id="DoubleSlash">
<source>1. Double-slash comments. These are used in most situations.</source>
<target state="translated">1. 双斜线注释。 此类注释用于大多数情况。</target>
<note />
</trans-unit>
<trans-unit id="MLStyle">
<source>2. ML-style Block comments. These aren't used that often.</source>
<target state="translated">2. ML 样式块注释。此类注释不经常使用。</target>
<note />
</trans-unit>
<trans-unit id="TripleSlash-Line1">
<source>3. Triple-slash comments. These are used for documenting functions, types, and so on.</source>
<target state="translated">3. 三斜线注释。此类注释用于记录功能和类型等。</target>
<note />
</trans-unit>
<trans-unit id="TripleSlash-Line2">
<source>They will appear as text when you hover over something which is decorated with these comments.</source>
<target state="translated">光标悬停在附带有注释的位置时，这些注释会以文本形式显示。</target>
<note />
</trans-unit>
<trans-unit id="XmlComments-Line1">
<source>They also support .NET-style XML comments, which allow you to generate reference documentation,</source>
<target state="translated">它们还支持 .NET 样式的 XML 注释，这些注释可生成参考文档，</target>
<note />
</trans-unit>
<trans-unit id="XmlComments-Line2">
<source>and they also allow editors (such as Visual Studio) to extract information from them.</source>
<target state="translated">还可允许编辑器(例如 Visual Studio)从其中提取信息。</target>
<note />
</trans-unit>
<trans-unit id="XmlComments-Line3">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/xml-documentation</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/xml-documentation</target>
<note />
</trans-unit>
<trans-unit id="OpenNamespaces">
<source>Open namespaces using the 'open' keyword.</source>
<target state="translated">使用 "open" 关键字打开命名空间。</target>
<note />
</trans-unit>
<trans-unit id="LearnMore">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/import-declarations-the-open-keyword</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/import-declarations-the-open-keyword</target>
<note />
</trans-unit>
<trans-unit id="Module-Line1">
<source>A module is a grouping of F# code, such as values, types, and function values.</source>
<target state="translated">模块是值、类型和函数值等 F# 代码的分组。</target>
<note />
</trans-unit>
<trans-unit id="Module-Line2">
<source>Grouping code in modules helps keep related code together and helps avoid name conflicts in your program.</source>
<target state="translated">用模块分组代码有助于汇集相关代码和避免程序中出现名称冲突。</target>
<note />
</trans-unit>
<trans-unit id="Module-Line3">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/modules</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/modules</target>
<note />
</trans-unit>
<trans-unit id="SampleInt">
<source>This is a sample integer.</source>
<target state="translated">此为示例整数。</target>
<note />
</trans-unit>
<trans-unit id="SampleFloat">
<source>This is a sample floating point number.</source>
<target state="translated">此为示例浮点数。</target>
<note />
</trans-unit>
<trans-unit id="Computed-Line1">
<source>This computed a new number by some arithmetic. Numeric types are converted using</source>
<target state="translated">这按照某种运算方法计算新的数字。数字类型通过</target>
<note />
</trans-unit>
<trans-unit id="Computed-Line2">
<source>functions 'int', 'double' and so on.</source>
<target state="translated">"int"、"double" 等函数进行转换。</target>
<note />
</trans-unit>
<trans-unit id="ListNumbers">
<source>This is a list of the numbers from 0 to 99.</source>
<target state="translated">这是从 0 到 99 的数字列表</target>
<note />
</trans-unit>
<trans-unit id="ListSquares">
<source>This is a list of all tuples containing all the numbers from 0 to 99 and their squares.</source>
<target state="translated">这是包含从 0 到 99 的所有数字及其平方的所有元组的列表.</target>
<note />
</trans-unit>
<trans-unit id="PrintList1">
<source>The next line prints a list that includes tuples, using '%A' for generic printing.</source>
<target state="translated">下一行打印包含元组的列表，使用 "%A" 来进行一般打印。</target>
<note />
</trans-unit>
<trans-unit id="SampleIntType">
<source>This is a sample integer with a type annotation</source>
<target state="translated">这是一个具有类型注释的示例整数</target>
<note />
</trans-unit>
<trans-unit id="ValuesImmutable-Line1">
<source>Values in F# are immutable by default. They cannot be changed</source>
<target state="translated">F# 中的值默认为不可变。程序执行过程中</target>
<note />
</trans-unit>
<trans-unit id="ValuesImmutable-Line2">
<source>in the course of a program's execution unless explicitly marked as mutable.</source>
<target state="translated">这些值无法更改，除非被显式标记为可变。</target>
<note />
</trans-unit>
<trans-unit id="ValuesImmutable-Line3">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/values/index#why-immutable</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/values/index#why-immutable</target>
<note />
</trans-unit>
<trans-unit id="LetKeyword-Line1">
<source>Binding a value to a name via 'let' makes it immutable.</source>
<target state="translated">通过 "let" 将值绑定到名称可使其不可变。</target>
<note />
</trans-unit>
<trans-unit id="LetKeyword-Line2">
<source>The second line of code fails to compile because 'number' is immutable and bound.</source>
<target state="translated">未能编译第二行代码，因为 "number" 不可变且已绑定。</target>
<note />
</trans-unit>
<trans-unit id="LetKeyword-Line3">
<source>Re-defining 'number' to be a different value is not allowed in F#.</source>
<target state="translated">F# 中不允许将 "number" 重定义为其他值。</target>
<note />
</trans-unit>
<trans-unit id="MutableKeyword">
<source>A mutable binding. This is required to be able to mutate the value of 'otherNumber'.</source>
<target state="translated">一个可变绑定。必须提供这种绑定才能改变 "otherNumber" 的值。</target>
<note />
</trans-unit>
<trans-unit id="MutableAssignment-Line1">
<source>When mutating a value, use '<-' to assign a new value.</source>
<target state="translated">若要改变值，请使用 "<-" 分配新值。</target>
<note />
</trans-unit>
<trans-unit id="MutableAssignment-Line2">
<source>You could not use '=' here for this purpose since it is used for equality</source>
<target state="translated">在这里不能将 "=" 用作此目的，因为该符号用于表示等式</target>
<note />
</trans-unit>
<trans-unit id="MutableAssignment-Line3">
<source>or other contexts such as 'let' or 'module'</source>
<target state="translated">或者 "let" 或 "module" 等其他上下文</target>
<note />
</trans-unit>
<trans-unit id="FunctionsModule-Line1">
<source>Much of F# programming consists of defining functions that transform input data to produce</source>
<target state="translated">大部分 F# 编程包括定义函数，该函数转换输入数据以生成</target>
<note />
</trans-unit>
<trans-unit id="FunctionsModule-Line2">
<source>useful results.</source>
<target state="translated">有用的结果。</target>
<note />
</trans-unit>
<trans-unit id="FunctionsModule-Line3">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/functions/</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/functions/</target>
<note />
</trans-unit>
<trans-unit id="LetFunction-Line1">
<source>You use 'let' to define a function. This one accepts an integer argument and returns an integer.</source>
<target state="translated">可使用 "let" 定义函数。它将接受整数参数，然后返回整数。</target>
<note />
</trans-unit>
<trans-unit id="LetFunction-Line2">
<source>Parentheses are optional for function arguments, except for when you use an explicit type annotation.</source>
<target state="translated">括号对函数参数是可选的，但使用显示类型注释时除外。</target>
<note />
</trans-unit>
<trans-unit id="ApplyFunction-Line1">
<source>Apply the function, naming the function return result using 'let'.</source>
<target state="translated">应用函数，并使用“let”命名函数返回结果。</target>
<note />
</trans-unit>
<trans-unit id="ApplyFunction-Line2">
<source>The variable type is inferred from the function return type.</source>
<target state="translated">变量类型是从函数返回类型推导出来的。</target>
<note />
</trans-unit>
<trans-unit id="printf-Line1">
<source>This line uses '%d' to print the result as an integer. This is type-safe.</source>
<target state="translated">该行用 "%d" 将结果作为整数进行打印。这属于类型安全。</target>
<note />
</trans-unit>
<trans-unit id="printf-Line2">
<source>If 'result1' were not of type 'int', then the line would fail to compile.</source>
<target state="translated">如果 "result1" 不是类型 "int"，则将无法编译该行。</target>
<note />
</trans-unit>
<trans-unit id="TypeAnnotation">
<source>When needed, annotate the type of a parameter name using '(argument:type)'. Parentheses are required.</source>
<target state="translated">如有需要，可使用 "(argument:type)" 批注参数名称类型。括号是必需的。</target>
<note />
</trans-unit>
<trans-unit id="Conditionals-Line1">
<source>Conditionals use if/then/elid/elif/else.</source>
<target state="translated">条件语句使用 if/then/elid/elif/else。</target>
<note />
</trans-unit>
<trans-unit id="Conditionals-Line2">
<source>Note that F# uses whitespace indentation-aware syntax, similar to languages like Python.</source>
<target state="translated">注意，F# 使用可识别空格缩进的语法，与 Python 等语言类似。</target>
<note />
</trans-unit>
<trans-unit id="printf-Line3">
<source>This line uses '%f' to print the result as a float. As with '%d' above, this is type-safe.</source>
<target state="translated">此行使用 "%f" 将结果作为浮点打印。与上述 "%d" 情况一样，属于类型安全。</target>
<note />
</trans-unit>
<trans-unit id="Booleans-Line1">
<source>Booleans are fundamental data types in F#. Here are some examples of Booleans and conditional logic.</source>
<target state="translated">布尔是 F# 中的基本数据类型。下面是一些布尔值和条件逻辑示例。</target>
<note />
</trans-unit>
<trans-unit id="Booleans-Line2">
<source>To learn more, see:</source>
<target state="translated">有关详细信息，请参阅:</target>
<note />
</trans-unit>
<trans-unit id="Booleans-Line3">
<source>and</source>
<target state="translated">和</target>
<note />
</trans-unit>
<trans-unit id="BooleanValues">
<source>Booleans values are 'true' and 'false'.</source>
<target state="translated">布尔值为 "true" 和 "false"。</target>
<note />
</trans-unit>
<trans-unit id="BooleanOperators">
<source>Operators on booleans are 'not', '&&' and '||'.</source>
<target state="translated">布尔运算符为 "not"、"&&" 和 "||"。</target>
<note />
</trans-unit>
<trans-unit id="BooleanPrintf">
<source>This line uses '%b'to print a boolean value. This is type-safe.</source>
<target state="translated">本行用 "%b" 打印布尔值。这属于类型安全。</target>
<note />
</trans-unit>
<trans-unit id="Strings-Line1">
<source>Strings are fundamental data types in F#. Here are some examples of Strings and basic String manipulation.</source>
<target state="translated">字符串是 F# 中的基本数据类型。下面是一些字符串和基本的字符串操作示例。</target>
<note />
</trans-unit>
<trans-unit id="Strings-Line2">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/strings</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/strings</target>
<note />
</trans-unit>
<trans-unit id="StringQuotes">
<source>Strings use double quotes.</source>
<target state="translated">字符串使用双引号。</target>
<note />
</trans-unit>
<trans-unit id="StringLiterals-Line1">
<source>Strings can also use @ to create a verbatim string literal.</source>
<target state="translated">字符串也可使用 @ 创建逐字的字符串。</target>
<note />
</trans-unit>
<trans-unit id="StringLiterals-Line2">
<source>This will ignore escape characters such as '\', '\n', '\t', etc.</source>
<target state="translated">这将忽略转义字符，如 "\", "\n", "\t" 等。</target>
<note />
</trans-unit>
<trans-unit id="StringTripleQuotes">
<source>String literals can also use triple-quotes.</source>
<target state="translated">字符串文本也可使用三重引号。</target>
<note />
</trans-unit>
<trans-unit id="StringConcatenation">
<source>String concatenation is normally done with the '+' operator.</source>
<target state="translated">字符串串联通常是用 "+" 运算符完成的。</target>
<note />
</trans-unit>
<trans-unit id="StringPrinting">
<source>This line uses '%s' to print a string value. This is type-safe.</source>
<target state="translated">本行用 "%s" 打印字符串值。这属于类型安全。</target>
<note />
</trans-unit>
<trans-unit id="Substrings-Line1">
<source>Substrings use the indexer notation. This line extracts the first 7 characters as a substring.</source>
<target state="translated">子字符串使用索引表示法。此行提取前 7 个字符作为子字符串。</target>
<note />
</trans-unit>
<trans-unit id="Substrings-Line2">
<source>Note that like many languages, Strings are zero-indexed in F#.</source>
<target state="translated">注意，与许多语言相同，字符串在 F# 中从零开始编制索引。</target>
<note />
</trans-unit>
<trans-unit id="Tuples-Line1">
<source>Tuples are simple combinations of data values into a combined value.</source>
<target state="translated">元组是组合成组合值的简单数据值组合。</target>
<note />
</trans-unit>
<trans-unit id="Tuples-Line2">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/tuples</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/tuples</target>
<note />
</trans-unit>
<trans-unit id="TupleInteger">
<source>A simple tuple of integers.</source>
<target state="translated">一个包含整数的简单元组。</target>
<note />
</trans-unit>
<trans-unit id="TupleFunction-Line1">
<source>A function that swaps the order of two values in a tuple.</source>
<target state="translated">一个用于交换两个值在元组中的顺序的函数。</target>
<note />
</trans-unit>
<trans-unit id="TupleFunction-Line2">
<source>F# Type Inference will automatically generalize the function to have a generic type,</source>
<target state="translated">F# 类型推理可自动泛化函数，使其具有泛型类型，</target>
<note />
</trans-unit>
<trans-unit id="TupleFunction-Line3">
<source>meaning that it will work with any type.</source>
<target state="translated">意味着它可与任何类型兼容。</target>
<note />
</trans-unit>
<trans-unit id="TupleMultiType-Line1">
<source>A tuple consisting of an integer, a string,</source>
<target state="translated">一个整数，一个字符串以及</target>
<note />
</trans-unit>
<trans-unit id="TupleMultiType-Line2">
<source>and a double-precision floating point number.</source>
<target state="translated">一个双精度浮点数字组成的元组。</target>
<note />
</trans-unit>
<trans-unit id="TupleTypeAnnotation-Line1">
<source>A simple tuple of integers with a type annotation.</source>
<target state="translated">一个具有类型批注的简单的整数元组。</target>
<note />
</trans-unit>
<trans-unit id="TupleTypeAnnotation-Line2">
<source>Type annotations for tuples use the * symbol to separate elements</source>
<target state="translated">元组的类型批注使用 * 号来分隔元素</target>
<note />
</trans-unit>
<trans-unit id="StructTuple-Line1">
<source>Tuples are normally objects, but they can also be represented as structs.</source>
<target state="translated">元组通常为对象，但也可表示为结构。</target>
<note />
</trans-unit>
<trans-unit id="StructTuple-Line2">
<source>These interoperate completely with structs in C# and Visual Basic.NET; however,</source>
<target state="translated">这些可在 C# 和 Visual Basic.NET 中与结构完全进行交互操作；然而，</target>
<note />
</trans-unit>
<trans-unit id="StructTuple-Line3">
<source>struct tuples are not implicitly convertable with object tuples (often called reference tuples).</source>
<target state="translated">结构元组不隐式转换为对象元组(通常称为引用元组)。</target>
<note />
</trans-unit>
<trans-unit id="StructTuple-Line4">
<source>The second line below will fail to compile because of this. Uncomment it to see what happens.</source>
<target state="translated">下面的第二行将因此无法编译。取消注释观察将发生什么。</target>
<note />
</trans-unit>
<trans-unit id="TupleConvert-Line1">
<source>Although you cannot implicitly convert between struct tuples and reference tuples,</source>
<target state="translated">尽管不能在结构元组和引用元组之间进行隐式转换，</target>
<note />
</trans-unit>
<trans-unit id="TupleConvert-Line2">
<source>you can explicitly convert via pattern matching, as demonstrated below.</source>
<target state="translated">可通过模式匹配进行显式转换，如下所示。</target>
<note />
</trans-unit>
<trans-unit id="Pipes-Line1">
<source>The F# pipe operators ('|>', '<|', etc.) and F# composition operators ('>>', '<<')</source>
<target state="translated">F# 管道运算符("|>"、"<|" 等 )和 F# 组合运算符(">>"、"<<")</target>
<note />
</trans-unit>
<trans-unit id="Pipes-Line2">
<source>are used extensively when processing data. These operators are themselves functions</source>
<target state="translated">广泛用于数据处理。这些运算符本身就是函数，</target>
<note />
</trans-unit>
<trans-unit id="Pipes-Line3">
<source>which make use of Partial Application.</source>
<target state="translated">它使用偏函数应用。</target>
<note />
</trans-unit>
<trans-unit id="Pipes-Line4">
<source>To learn more about these operators, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/functions/#function-composition-and-pipelining</source>
<target state="translated">若要深入了解这些运算符，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/functions/#function-composition-and-pipelining</target>
<note />
</trans-unit>
<trans-unit id="Pipes-Line5">
<source>To learn more about Partial Application, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/functions/#partial-application-of-arguments</source>
<target state="translated">若要深入了解偏函数应用，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/functions/#partial-application-of-arguments</target>
<note />
</trans-unit>
<trans-unit id="Squares">
<source>Squares a value.</source>
<target state="translated">计算值的平方。</target>
<note />
</trans-unit>
<trans-unit id="AddOne">
<source>Adds 1 to a value.</source>
<target state="translated">将值加 1。</target>
<note />
</trans-unit>
<trans-unit id="TestOdd">
<source>Tests if an integer value is odd via modulo.</source>
<target state="translated">通过取模测试整数是否为奇数。</target>
<note />
</trans-unit>
<trans-unit id="NumberList1">
<source>A list of 5 numbers. More on lists later.</source>
<target state="translated">包含 5 个数字的列表。稍后列表上会有更多数字。</target>
<note />
</trans-unit>
<trans-unit id="FilterWithoutPipes-Line1">
<source>Given a list of integers, it filters out the even numbers,</source>
<target state="translated">如果是整数列表，它会筛选出偶数。</target>
<note />
</trans-unit>
<trans-unit id="FilterWithoutPipes-Line2">
<source>squares the resulting odds, and adds 1 to the squared odds.</source>
<target state="translated">将产生的奇数平方，然后将奇数平方值加 1。</target>
<note />
</trans-unit>
<trans-unit id="FilterShorter-Line1">
<source>A shorter way to write 'squareOddValuesAndAddOne' is to nest each</source>
<target state="translated">编写 "squareOddValuesAndAddOne" 的简便方法是将每个</target>
<note />
</trans-unit>
<trans-unit id="FilterShorter-Line2">
<source>sub-result into the function calls themselves.</source>
<target state="translated">子结果嵌入函数调用本身。</target>
<note />
</trans-unit>
<trans-unit id="FilterShorter-Line3">
<source>This makes the function much shorter, but it's difficult to see the</source>
<target state="translated">这将使函数短得多，但难以查看</target>
<note />
</trans-unit>
<trans-unit id="FilterShorter-Line4">
<source>order in which the data is processed.</source>
<target state="translated">处理数据的顺序。</target>
<note />
</trans-unit>
<trans-unit id="FilterWithPipes-Line1">
<source>A preferred way to write 'squareOddValuesAndAddOne' is to use F# pipe operators.</source>
<target state="translated">编写 "squareOddValuesAndAddOne" 的首选方法是使用 F# 管道运算符。</target>
<note />
</trans-unit>
<trans-unit id="FilterWithPipes-Line2">
<source>This allows you to avoid creating intermediate results, but is much more readable</source>
<target state="translated">这可使你避免产生中间结果，而且可读性更好</target>
<note />
</trans-unit>
<trans-unit id="FilterWithPipes-Line3">
<source>than nesting function calls like 'squareOddValuesAndAddOneNested'</source>
<target state="translated">嵌入式函数调用(如 "squareOddValuesAndAddOneNested")更具可读性</target>
<note />
</trans-unit>
<trans-unit id="PipeInLambda-Line1">
<source>You can shorten 'squareOddValuesAndAddOnePipeline' by moving the second `List.map` call</source>
<target state="translated">使用 Lambda 函数，通过将第二个 "List.map" 调用移动到第一个，</target>
<note />
</trans-unit>
<trans-unit id="PipeInLambda-Line2">
<source>into the first, using a Lambda Function.</source>
<target state="translated">可以缩短 "squareOddValuesAndAddOnePipeline"。</target>
<note />
</trans-unit>
<trans-unit id="PipeInLambda-Line3">
<source>Note that pipelines are also being used inside the lambda function. F# pipe operators</source>
<target state="translated">注意，管道也在 lambda 函数内使用。F# 管道运算符</target>
<note />
</trans-unit>
<trans-unit id="PipeInLambda-Line4">
<source>can be used for single values as well. This makes them very powerful for processing data.</source>
<target state="translated">还可用于单个值。这使它们处理数据的功能很强大。</target>
<note />
</trans-unit>
<trans-unit id="PipesComposition-Line1">
<source>Lastly, you can eliminate the need to explicitly take 'values' in as a parameter by using '>>'</source>
<target state="translated">最后，无需再将 "value" 显式作为参数，你可使用 ">>"</target>
<note />
</trans-unit>
<trans-unit id="PipesComposition-Line2">
<source>to compose the two core operations: filtering out even numbers, then squaring and adding one.</source>
<target state="translated">以合成两个核心运算: 筛选出偶数，然后平方并加 1。</target>
<note />
</trans-unit>
<trans-unit id="PipesComposition-Line3">
<source>Likewise, the 'fun x -> ...' bit of the lambda expression is also not needed, because 'x' is simply</source>
<target state="translated">同样，lambda 表达式的 "fun x -> ..." 也不需要了，因为 "x" 只是</target>
<note />
</trans-unit>
<trans-unit id="PipesComposition-Line4">
<source>being defined in that scope so that it can be passed to a functional pipeline. Thus, '>>' can be used</source>
<target state="translated">在该范围内定义，以便可传递到功能管道。因此，也可将 ">>"</target>
<note />
</trans-unit>
<trans-unit id="PipesComposition-Line5">
<source>there as well.</source>
<target state="translated">用在该处。</target>
<note />
</trans-unit>
<trans-unit id="PipesComposition-Line6">
<source>The result of 'squareOddValuesAndAddOneComposition' is itself another function which takes a</source>
<target state="translated">"squareOddValuesAndAddOneComposition" 的结果本身就是另一个函数，它</target>
<note />
</trans-unit>
<trans-unit id="PipesComposition-Line7">
<source>list of integers as its input. If you execute 'squareOddValuesAndAddOneComposition' with a list</source>
<target state="translated">将整数列表作为其输入值。如果使用整数列表执行 "squareOddValuesAndAddOneComposition"，</target>
<note />
</trans-unit>
<trans-unit id="PipesComposition-Line8">
<source>of integers, you'll notice that it produces the same results as previous functions.</source>
<target state="translated">你将发现它与上述函数产生的结果相同。</target>
<note />
</trans-unit>
<trans-unit id="PipesComposition-Line9">
<source>This is using what is known as function composition. This is possible because functions in F#</source>
<target state="translated">这使用的就是所谓的函数组合。这是可能的，因为 F# 中的函数</target>
<note />
</trans-unit>
<trans-unit id="PipesComposition-Line10">
<source>use Partial Application and the input and output types of each data processing operation match</source>
<target state="translated">使用偏函数应用，并且每个数据处理操作的输入和输出类型与</target>
<note />
</trans-unit>
<trans-unit id="PipesComposition-Line11">
<source>the signatures of the functions we're using.</source>
<target state="translated">我们使用的函数签名。</target>
<note />
</trans-unit>
<trans-unit id="Lists-Line1">
<source>Lists are ordered, immutable, singly-linked lists. They are eager in their evaluation.</source>
<target state="translated">列表属于有序、不可变、单向链接的列表。它们都采用主动求值方式。</target>
<note />
</trans-unit>
<trans-unit id="Lists-Line2">
<source>This module shows various ways to generate lists and process lists with some functions</source>
<target state="translated">本模块介绍使用某些函数生成列表和处理列表的各种方法</target>
<note />
</trans-unit>
<trans-unit id="Lists-Line3">
<source>in the 'List' module in the F# Core Library.</source>
<target state="translated">在 F# 核心库的 "List" 模块中。</target>
<note />
</trans-unit>
<trans-unit id="Lists-Line4">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/lists</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/lists</target>
<note />
</trans-unit>
<trans-unit id="ListEmptyDefinition">
<source>Lists are defined using [ ... ]. This is an empty list.</source>
<target state="translated">使用 [ ... ] 定义列表。这是空列表。</target>
<note />
</trans-unit>
<trans-unit id="ListElementDefinition">
<source>This is a list with 3 elements. ';' is used to separate elements on the same line.</source>
<target state="translated">这是一个包含 3 个元素的列表。";" 用于分隔同一行的元素。</target>
<note />
</trans-unit>
<trans-unit id="ListNewlineElements">
<source>You can also separate elements by placing them on their own lines.</source>
<target state="translated">也可通过将各元素放在其自身行来分隔。</target>
<note />
</trans-unit>
<trans-unit id="NumberList2">
<source>This is a list of integers from 1 to 1000</source>
<target state="translated">这是从 1 到 1000 的整数列表</target>
<note />
</trans-unit>
<trans-unit id="ListComputation-Line1">
<source>Lists can also be generated by computations. This is a list containing</source>
<target state="translated">也可通过计算来生成列表。此列表包含</target>
<note />
</trans-unit>
<trans-unit id="ListComputation-Line2">
<source>all the days of the year.</source>
<target state="translated">一年的所有天。</target>
<note />
</trans-unit>
<trans-unit id="PrintList2">
<source>Print the first 5 elements of 'daysList' using 'List.take'.</source>
<target state="translated">使用 "List.take" 打印 "daysList" 的前 5 个元素。</target>
<note />
</trans-unit>
<trans-unit id="ListComputationConditional-Line1">
<source>Computations can include conditionals. This is a list containing the tuples</source>
<target state="translated">计算可以包括条件。这是包含元组的列表</target>
<note />
</trans-unit>
<trans-unit id="ListComputationConditional-Line2">
<source>which are the coordinates of the black squares on a chess board.</source>
<target state="translated">这是棋盘上黑色方格的坐标。</target>
<note />
</trans-unit>
<trans-unit id="ListMap-Line1">
<source>Lists can be transformed using 'List.map' and other functional programming combinators.</source>
<target state="translated">列表可使用 "List.map" 和其他函数编程连结符进行转换。</target>
<note />
</trans-unit>
<trans-unit id="ListMap-Line2">
<source>This definition produces a new list by squaring the numbers in numberList, using the pipeline</source>
<target state="translated">此定义通过使用管道将 numberList 中的数字进行平方运算来生成新列表</target>
<note />
</trans-unit>
<trans-unit id="ListMap-Line3">
<source>operator to pass an argument to List.map.</source>
<target state="translated">将参数传递给 List.map 的运算符。</target>
<note />
</trans-unit>
<trans-unit id="ListFilter-Line1">
<source>There are many other list combinations. The following computes the sum of the squares of the</source>
<target state="translated">还有许多其他列表组合。下面计算以下内容的平方和:</target>
<note />
</trans-unit>
<trans-unit id="ListFilter-Line2">
<source>numbers divisible by 3.</source>
<target state="translated">数字可被 3 整除。</target>
<note />
</trans-unit>
<trans-unit id="Arrays-Line1">
<source>Arrays are fixed-size, mutable collections of elements of the same type.</source>
<target state="translated">数组是固定大小，同类型元素的可变集合。</target>
<note />
</trans-unit>
<trans-unit id="Arrays-Line2">
<source>Although they are similar to Lists (they support enumeration and have similar combinators for data processing),</source>
<target state="translated">尽管它们与列表相同(支持枚举，且具有用于数据处理的类似连接符)，</target>
<note />
</trans-unit>
<trans-unit id="Arrays-Line3">
<source>they are generally faster and support fast random access. This comes at the cost of being less safe by being mutable.</source>
<target state="translated">它们通常速度更快，且支持快速随机访问。代价是因为可变而不太安全。</target>
<note />
</trans-unit>
<trans-unit id="Arrays-Line4">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/arrays</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/arrays</target>
<note />
</trans-unit>
<trans-unit id="EmptyArray">
<source>This is The empty array. Note that the syntax is similar to that of Lists, but uses `[| ... |]` instead.</source>
<target state="translated">这是空数组。注意，语法与列表类似，但改用 `[| ... |]`。</target>
<note />
</trans-unit>
<trans-unit id="ArrayConstructionList">
<source>Arrays are specified using the same range of constructs as lists.</source>
<target state="translated">使用与列表相同的构造范围来指定数组。</target>
<note />
</trans-unit>
<trans-unit id="ArrayConstructionRange">
<source>This is an array of numbers from 1 to 1000.</source>
<target state="translated">这是从 1 到 1000 的数字数组。</target>
<note />
</trans-unit>
<trans-unit id="ArrayComputationConstruction">
<source>This is an array containing only the words "hello" and "world".</source>
<target state="translated">这是只包含单词 "hello" 和 "world" 的数组。</target>
<note />
</trans-unit>
<trans-unit id="ArrayInit">
<source>This is an array initialized by index and containing the even numbers from 0 to 2000.</source>
<target state="translated">这是由索引初始化的数组，包含从 0 到 2000 之间的偶数。</target>
<note />
</trans-unit>
<trans-unit id="ArraySlicing">
<source>Sub-arrays are extracted using slicing notation.</source>
<target state="translated">使用切片表示法提取子数组。</target>
<note />
</trans-unit>
<trans-unit id="ArrayLooping">
<source>You can loop over arrays and lists using 'for' loops.</source>
<target state="translated">可使用 "for" 循环循环数组和列表。</target>
<note />
</trans-unit>
<trans-unit id="ArrayAssignment-Line1">
<source>You can modify the contents of an an array element by using the left arrow assignment operator.</source>
<target state="translated">可使用左箭头赋值运算符来修改数组元素的内容。</target>
<note />
</trans-unit>
<trans-unit id="ArrayAssignment-Line2">
<source>To learn more about this operator, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/values/index#mutable-variables</source>
<target state="translated">若要深入了解此运算符，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/values/index#mutable-variables</target>
<note />
</trans-unit>
<trans-unit id="ArrayMap-Line1">
<source>You can transform arrays using 'Array.map' and other functional programming operations.</source>
<target state="translated">可使用 "Array.map" 和其他功能性编程运算来转换数组。</target>
<note />
</trans-unit>
<trans-unit id="ArrayMap-Line2">
<source>The following calculates the sum of the lengths of the words that start with 'h'.</source>
<target state="translated">下面的函数计算以 "h" 开头的单词的总长度。</target>
<note />
</trans-unit>
<trans-unit id="Sequences-Line1">
<source>Sequences are a logical series of elements, all of the same type. These are a more general type than Lists and Arrays.</source>
<target state="translated">序列是类型相同的所有元素的逻辑系列。序列是比列表和数组更常规的类型。</target>
<note />
</trans-unit>
<trans-unit id="Sequences-Line2">
<source>Sequences are evaluated on-demand and are re-evaluated each time they are iterated.</source>
<target state="translated">将根据需要计算序列，并在每次循环访问它们时重新进行计算。</target>
<note />
</trans-unit>
<trans-unit id="Sequences-Line3">
<source>An F# sequence is an alias for a .NET System.Collections.Generic.IEnumerable<'T>.</source>
<target state="translated">F# 序列是 .NET System.Collections.Generic.IEnumerable<'T> 的别名。</target>
<note />
</trans-unit>
<trans-unit id="Sequences-Line4">
<source>Sequence processing functions can be applied to Lists and Arrays as well.</source>
<target state="translated">序列处理函数也可以应用于列表和数组。</target>
<note />
</trans-unit>
<trans-unit id="Sequences-Line5">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/sequences</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/sequences</target>
<note />
</trans-unit>
<trans-unit id="EmptySequence">
<source>This is the empty sequence.</source>
<target state="translated">这是空序列。</target>
<note />
</trans-unit>
<trans-unit id="SequenceOfValues">
<source>This a sequence of values.</source>
<target state="translated">这是一个值的序列。</target>
<note />
</trans-unit>
<trans-unit id="OnDemandSequence">
<source>This is an on-demand sequence from 1 to 1000.</source>
<target state="translated">这是从 1 到 1000 的按需序列。</target>
<note />
</trans-unit>
<trans-unit id="SequenceComposition">
<source>This is a sequence producing the words "hello" and "world"</source>
<target state="translated">这是生成单词 "hello" 和 "world" 的序列</target>
<note />
</trans-unit>
<trans-unit id="SequenceInit">
<source>This sequence producing the even numbers up to 2000.</source>
<target state="translated">此序列生成最大为 2000 的偶数。</target>
<note />
</trans-unit>
<trans-unit id="InfiniteSequence-Line1">
<source>This is an infinite sequence which is a random walk.</source>
<target state="translated">这是可随机访问的无限序列。</target>
<note />
</trans-unit>
<trans-unit id="InfiniteSequence-Line2">
<source>This example uses yield! to return each element of a subsequence.</source>
<target state="translated">此示例使用 yield! 返回子序列的每个元素。</target>
<note />
</trans-unit>
<trans-unit id="Sequence100Elements">
<source>This example shows the first 100 elements of the random walk.</source>
<target state="translated">此示例演示随机访问的前 100 个元素。</target>
<note />
</trans-unit>
<trans-unit id="RecursiveFunctions-Line1">
<source>Recursive functions can call themselves. In F#, functions are only recursive</source>
<target state="translated">递归函数可调用其自身。在 F# 中，函数只递归</target>
<note />
</trans-unit>
<trans-unit id="RecursiveFunctions-Line2">
<source>when declared using 'let rec'.</source>
<target state="translated">使用 "let rec" 声明时。</target>
<note />
</trans-unit>
<trans-unit id="RecursiveFunctions-Line3">
<source>Recursion is the preferred way to process sequences or collections in F#.</source>
<target state="translated">递归是 F# 中处理序列或集合的首选方式。</target>
<note />
</trans-unit>
<trans-unit id="RecursiveFunctions-Line4">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/functions/index#recursive-functions</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/functions/index#recursive-functions</target>
<note />
</trans-unit>
<trans-unit id="RecFunDef-Line1">
<source>This example shows a recursive function that computes the factorial of an</source>
<target state="translated">此示例演示递归函数，计算以下内容的阶乘:</target>
<note />
</trans-unit>
<trans-unit id="RecRunDef-Line2">
<source>integer. It uses 'let rec' to define a recursive function.</source>
<target state="translated">整数。它使用 "let rec" 来定义递归函数。</target>
<note />
</trans-unit>
<trans-unit id="RecGcd-Line1">
<source>Computes the greatest common factor of two integers.</source>
<target state="translated">计算两个整数的最大公因数。</target>
<note />
</trans-unit>
<trans-unit id="RecGcd-Line2">
<source>Since all of the recursive calls are tail calls,</source>
<target state="translated">由于所有递归调用都是尾调用，</target>
<note />
</trans-unit>
<trans-unit id="RecGcd-Line3">
<source>the compiler will turn the function into a loop,</source>
<target state="translated">因此编译器会将该函数转变成一个循环，</target>
<note />
</trans-unit>
<trans-unit id="RecGcd-Line4">
<source>which improves performance and reduces memory consumption.</source>
<target state="translated">这可提高性能并减少内存消耗。</target>
<note />
</trans-unit>
<trans-unit id="RecSumList">
<source>This example computes the sum of a list of integers using recursion.</source>
<target state="translated">本示例使用递归计算整数列表的总和。</target>
<note />
</trans-unit>
<trans-unit id="RecSumListTail">
<source>This makes 'sumList' tail recursive, using a helper function with a result accumulator.</source>
<target state="translated">通过将 Helper 函数与结果累加器一起使用，使 "sumList" 成为尾递归函数。</target>
<note />
</trans-unit>
<trans-unit id="RecSumListTailInvoke-Line1">
<source>This invokes the tail recursive helper function, providing '0' as a seed accumulator.</source>
<target state="translated">假如 "0" 作为种子累加器，这将调用尾递归 helper 函数。</target>
<note />
</trans-unit>
<trans-unit id="RecSumListTailInvoke-Line2">
<source>An approach like this is common in F#.</source>
<target state="translated">此类方法在 F# 中很常见。</target>
<note />
</trans-unit>
<trans-unit id="Records-Line1">
<source>Records are an aggregate of named values, with optional members (such as methods).</source>
<target state="translated">记录是已命名值的聚合，同时具有可选成员(例如，方法)。</target>
<note />
</trans-unit>
<trans-unit id="Records-Line2">
<source>They are immutable and have structural equality semantics.</source>
<target state="translated">它们不可变且具有结构相等性语义。</target>
<note />
</trans-unit>
<trans-unit id="Records-Line3">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/records</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/records</target>
<note />
</trans-unit>
<trans-unit id="RecordDefinition">
<source>This example shows how to define a new record type.</source>
<target state="translated">此示例演示如何定义新记录类型。</target>
<note />
</trans-unit>
<trans-unit id="RecordInstantiation1">
<source>This example shows how to instantiate a record type.</source>
<target state="translated">本示例演示如何实例化记录类型。</target>
<note />
</trans-unit>
<trans-unit id="RecordInstantiation2">
<source>You can also do this on the same line with ';' separators.</source>
<target state="translated">也可使用 ";" 分隔符在同一行上执行此操作。</target>
<note />
</trans-unit>
<trans-unit id="UpdateRecord-Line1">
<source>This example shows how to use "copy-and-update" on record values. It creates</source>
<target state="translated">此示例演示如何对记录值使用 "copy-and-update"。它创建了</target>
<note />
</trans-unit>
<trans-unit id="UpdateRecord-Line2">
<source>a new record value that is a copy of contact1, but has different values for</source>
<target state="translated">新的记录值，该值是 contact1 的副本，但对以下内容具有不同的值:</target>
<note />
</trans-unit>
<trans-unit id="UpdateRecord-Line3">
<source>the 'Phone' and 'Verified' fields.</source>
<target state="translated">“电话”和“已验证”字段。</target>
<note />
</trans-unit>
<trans-unit id="UpdateRecord-Line4">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/copy-and-update-record-expressions</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/copy-and-update-record-expressions</target>
<note />
</trans-unit>
<trans-unit id="ProcessRecord-Line1">
<source>This example shows how to write a function that processes a record value.</source>
<target state="translated">此示例演示如何编写处理记录值的函数。</target>
<note />
</trans-unit>
<trans-unit id="ProcessRecord-Line2">
<source>It converts a 'ContactCard' object to a string.</source>
<target state="translated">它将 "ContactCard" 对象转换为字符串。</target>
<note />
</trans-unit>
<trans-unit id="RecordWithMember-Line1">
<source>This is an example of a Record with a member.</source>
<target state="translated">这是一个具有成员的记录示例。</target>
<note />
</trans-unit>
<trans-unit id="RecordWithMember-Line2">
<source>Members can implement object-oriented members.</source>
<target state="translated">成员可实现面向对象的成员。</target>
<note />
</trans-unit>
<trans-unit id="RecordAccess">
<source>Members are accessed via the '.' operator on an instantiated type.</source>
<target state="translated">可通过实例化类型上的 "." 运算符访问成员。</target>
<note />
</trans-unit>
<trans-unit id="RecordStruct-Line1">
<source>Records can also be represented as structs via the 'Struct' attribute.</source>
<target state="translated">记录也可通过 "Struct" 属性表示为结构。</target>
<note />
</trans-unit>
<trans-unit id="RecordStruct-Line2">
<source>This is helpful in situations where the performance of structs outweighs</source>
<target state="translated">这在结构性能更重要的情况下很有用</target>
<note />
</trans-unit>
<trans-unit id="RecordStruct-Line3">
<source>the flexibility of reference types.</source>
<target state="translated">引用类型的灵活性。</target>
<note />
</trans-unit>
<trans-unit id="DiscriminatedUnions-Line1">
<source>Discriminated Unions (DU for short) are values which could be a number of named forms or cases.</source>
<target state="translated">可区分联合(简称 DU)的值可以是一系列已命名窗体或用例。</target>
<note />
</trans-unit>
<trans-unit id="DiscriminatedUnions-Line2">
<source>Data stored in DUs can be one of several distinct values.</source>
<target state="translated">DU 中存储的数据可以为多个不同值之一。</target>
<note />
</trans-unit>
<trans-unit id="DiscriminatedUnions-Line3">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/discriminated-unions</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/discriminated-unions</target>
<note />
</trans-unit>
<trans-unit id="CardSuit">
<source>The following represents the suit of a playing card.</source>
<target state="translated">下面代表一套扑克牌。</target>
<note />
</trans-unit>
<trans-unit id="CardRank">
<source>A Disciminated Union can also be used to represent the rank of a playing card.</source>
<target state="translated">可区分联合还可用来表示纸牌的设置级别。</target>
<note />
</trans-unit>
<trans-unit id="CardRankValue">
<source>Represents the rank of cards 2 .. 10</source>
<target state="translated">表示扑克牌点数 2 .. 10</target>
<note />
</trans-unit>
<trans-unit id="CardMember">
<source>Discriminated Unions can also implement object-oriented members.</source>
<target state="translated">可区分联合还可实现面向对象的成员。</target>
<note />
</trans-unit>
<trans-unit id="CardType-Line1">
<source>This is a record type that combines a Suit and a Rank.</source>
<target state="translated">这是结合花色和牌面大小的记录类型。</target>
<note />
</trans-unit>
<trans-unit id="CardType-Line2">
<source>It's common to use both Records and Disciminated Unions when representing data.</source>
<target state="translated">表示数据时同时使用记录和可区分联合是很常见的。</target>
<note />
</trans-unit>
<trans-unit id="ComputeFullDeck">
<source>This computes a list representing all the cards in the deck.</source>
<target state="translated">它将计算代表牌组中所有扑克牌的列表。</target>
<note />
</trans-unit>
<trans-unit id="CardToString">
<source>This example converts a 'Card' object to a string.</source>
<target state="translated">此示例将“纸牌”对象转换为字符串。</target>
<note />
</trans-unit>
<trans-unit id="PrintAllCards">
<source>This example prints all the cards in a playing deck.</source>
<target state="translated">此示例打印扑克牌中的所有牌。</target>
<note />
</trans-unit>
<trans-unit id="SingleCaseDu-Line1">
<source>Single-case DUs are often used for domain modeling. This can buy you extra type safety</source>
<target state="translated">单用例 DU 常用于域建模。这可确保额外类型的安全</target>
<note />
</trans-unit>
<trans-unit id="SingleCaseDu-Line2">
<source>over primitive types such as strings and ints.</source>
<target state="translated">字符串和整数等基元类型。</target>
<note />
</trans-unit>
<trans-unit id="SingleCaseDu-Line3">
<source>Single-case DUs cannot be implicitly converted to or from the type they wrap.</source>
<target state="translated">单用例 DU 无法隐式转换为其包装的类型或从其包装的类型进行转换。</target>
<note />
</trans-unit>
<trans-unit id="SingleCaseDu-Line4">
<source>For example, a function which takes in an Address cannot accept a string as that input,</source>
<target state="translated">例如，地址中采用的函数无法接受字符串作为输入，</target>
<note />
</trans-unit>
<trans-unit id="SingleCaseDu-Line5">
<source>or vive/versa.</source>
<target state="translated">反之亦然。</target>
<note />
</trans-unit>
<trans-unit id="InstantiateSingleCaseDu">
<source>You can easily instantiate a single-case DU as follows.</source>
<target state="translated">可轻松实例化单用例 DU，如下所示。</target>
<note />
</trans-unit>
<trans-unit id="UnwrapSingleCaseDu">
<source>When you need the value, you can unwrap the underlying value with a simple function.</source>
<target state="translated">需要值时，可使用单个函数解包基础值。</target>
<note />
</trans-unit>
<trans-unit id="PrintSingleCaseDu">
<source>Printing single-case DUs is simple with unwrapping functions.</source>
<target state="translated">打印单用例 DU 与解包函数一样简单。</target>
<note />
</trans-unit>
<trans-unit id="DuRecursiveDef-Line1">
<source>Disciminated Unions also support recursive definitions.</source>
<target state="translated">可区分联合还支持递归定义。</target>
<note />
</trans-unit>
<trans-unit id="DuRecursiveDef-Line2">
<source>This represents a Binary Search Tree, with one case being the Empty tree,</source>
<target state="translated">这代表一个二进制文件搜索树，且有一个用例为空树，</target>
<note />
</trans-unit>
<trans-unit id="DuRecursiveDef-Line3">
<source>and the other being a Node with a value and two subtrees.</source>
<target state="translated">而另一个用例为具有一个值和两个子树的节点。</target>
<note />
</trans-unit>
<trans-unit id="SearchBinaryTree-Line1">
<source>Check if an item exists in the binary search tree.</source>
<target state="translated">检查项是否存在于二进制文件搜索树中。</target>
<note />
</trans-unit>
<trans-unit id="SearchBinaryTree-Line2">
<source>Searches recursively using Pattern Matching. Returns true if it exists; otherwise, false.</source>
<target state="translated">使用模式匹配进行递归搜索。如果存在，则返回 true，否则返回 false。</target>
<note />
</trans-unit>
<trans-unit id="CheckLeftSubtree">
<source>Check the left subtree.</source>
<target state="translated">检查左子树。</target>
<note />
</trans-unit>
<trans-unit id="CheckRightSubtree">
<source>Check the right subtree.</source>
<target state="translated">检查右子树。</target>
<note />
</trans-unit>
<trans-unit id="BinaryTreeInsert-Line1">
<source>Inserts an item in the Binary Search Tree.</source>
<target state="translated">在二进制文件搜索树中插入项。</target>
<note />
</trans-unit>
<trans-unit id="BinaryTreeInsert-Line2">
<source>Finds the place to insert recursively using Pattern Matching, then inserts a new node.</source>
<target state="translated">查找使用模式匹配递归插入的位置，然后插入新节点。</target>
<note />
</trans-unit>
<trans-unit id="BinaryTreeInsert-Line3">
<source>If the item is already present, it does not insert anything.</source>
<target state="translated">如果项已存在，则不会插入任何内容。</target>
<note />
</trans-unit>
<trans-unit id="BinaryTreeInsert-Line4">
<source>No need to insert, it already exists; return the node.</source>
<target state="translated">无需插入，该项已存在；返回节点。</target>
<note />
</trans-unit>
<trans-unit id="BinaryTreeInsert-Line5">
<source>Call into left subtree.</source>
<target state="translated">调入左子树。</target>
<note />
</trans-unit>
<trans-unit id="BinaryTreeInsert-Line6">
<source>Call into right subtree.</source>
<target state="translated">调入右子树。</target>
<note />
</trans-unit>
<trans-unit id="DuStruct-Line1">
<source>Discriminated Unions can also be represented as structs via the 'Struct' attribute.</source>
<target state="translated">可区分联合也可通过 "Struct" 属性表示为结构。</target>
<note />
</trans-unit>
<trans-unit id="DuStruct-Line2">
<source>This is helpful in situations where the performance of structs outweighs</source>
<target state="translated">这在结构性能更重要的情况下很有用</target>
<note />
</trans-unit>
<trans-unit id="DuStruct-Line3">
<source>the flexibility of reference types.</source>
<target state="translated">引用类型的灵活性。</target>
<note />
</trans-unit>
<trans-unit id="DuStruct-Line4">
<source>However, there are two important things to know when doing this:</source>
<target state="translated">然而，执行此操作时需了解两个重要事项:</target>
<note />
</trans-unit>
<trans-unit id="DuStruct-Line5">
<source>1. A struct DU cannot be recursively-defined.</source>
<target state="translated">1. 无法以递归方式定义结构 DU。</target>
<note />
</trans-unit>
<trans-unit id="DuStruct-Line6">
<source>2. A struct DU must have unique names for each of its cases.</source>
<target state="translated">2. 结构 DU 必须对其每个用例均有唯一名称。</target>
<note />
</trans-unit>
<trans-unit id="PatternMatching-Line1">
<source>Pattern Matching is a feature of F# that allows you to utilize Patterns,</source>
<target state="translated">模式匹配是 F# 的一个功能，使你能够利用模式，</target>
<note />
</trans-unit>
<trans-unit id="PatternMatching-Line2">
<source>which are a way to compare data with a logical structure or structures,</source>
<target state="translated">它们是将数据与逻辑结构或结构进行比较的方法，</target>
<note />
</trans-unit>
<trans-unit id="PatternMatching-Line3">
<source>decompose data into constituent parts, or extract information from data in various ways.</source>
<target state="translated">将数据分解为各个构成部分，或通过各种方式从数据中提取信息。</target>
<note />
</trans-unit>
<trans-unit id="PatternMatching-Line4">
<source>You can then dispatch on the "shape" of a pattern via Pattern Matching.</source>
<target state="translated">然后，你便可以在模式的“形状”上通过模式匹配进行派遣。</target>
<note />
</trans-unit>
<trans-unit id="PatternMatching-Line5">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/pattern-matching</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/pattern-matching</target>
<note />
</trans-unit>
<trans-unit id="PersonRecord">
<source>A record for a person's first and last name</source>
<target state="translated">人员的姓氏和名字的记录</target>
<note />
</trans-unit>
<trans-unit id="EmployeeDu">
<source>A Discriminated Union of 3 different kinds of employees</source>
<target state="translated">具有 3 种不同员工的可区分联合</target>
<note />
</trans-unit>
<trans-unit id="CountEmployees-Line1">
<source>Count everyone underneath the employee in the management hierarchy,</source>
<target state="translated">在管理层次结构下对员工进行计数，</target>
<note />
</trans-unit>
<trans-unit id="CountEmployees-Line2">
<source>including the employee.</source>
<target state="translated">其中包括员工。</target>
<note />
</trans-unit>
<trans-unit id="FindDave-Line1">
<source>Find all managers/executives named "Dave" who do not have any reports.</source>
<target state="translated">查找所有名为 "Dave" 且没有任何下属的经理/主管。</target>
<note />
</trans-unit>
<trans-unit id="FindDave-Line2">
<source>This uses the 'function' shorthand to as a lambda expression.</source>
<target state="translated">这使用 "function" 简写为 lambda 表达式。</target>
<note />
</trans-unit>
<trans-unit id="MatchEmptyList">
<source>[] matches an empty list.</source>
<target state="translated">[] 匹配空列表。</target>
<note />
</trans-unit>
<trans-unit id="MatchWildcard-Line1">
<source>'_' is a wildcard pattern that matches anything.</source>
<target state="translated">"_" 是与任何对象均匹配的通配符模式。</target>
<note />
</trans-unit>
<trans-unit id="MatchWildCard-Line2">
<source>This handles the "or else" case.</source>
<target state="translated">它处理 "or else" 情况。</target>
<note />
</trans-unit>
<trans-unit id="MatchShorthand-Line1">
<source>You can also use the shorthand function construct for pattern matching,</source>
<target state="translated">你也可将简写函数构造用于模式匹配，</target>
<note />
</trans-unit>
<trans-unit id="MatchShorthand-Line2">
<source>which is useful when you're writing functions which make use of Partial Application.</source>
<target state="translated">这在编写使用偏函数应用的函数时很有用。</target>
<note />
</trans-unit>
<trans-unit id="ParseHelpers">
<source>Define some more functions which parse with the helper function.</source>
<target state="translated">定义更多使用 helper 函数分析的函数。</target>
<note />
</trans-unit>
<trans-unit id="ActivePatterns-Line1">
<source>Active Patterns are another powerful construct to use with pattern matching.</source>
<target state="translated">活动模式是另一个与模式匹配配合使用的强大构造。</target>
<note />
</trans-unit>
<trans-unit id="ActivePatterns-Line2">
<source>They allow you to partition input data into custom forms, decomposing them at the pattern match call site.</source>
<target state="translated">它们使你能够将输入数据分区到自定义窗体，然后在模式匹配调用站点分解它们。</target>
<note />
</trans-unit>
<trans-unit id="ActivePatterns-Line3">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/active-patterns</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/active-patterns</target>
<note />
</trans-unit>
<trans-unit id="MatchActivePattern">
<source>Pattern Matching via 'function' keyword and Active Patterns often looks like this.</source>
<target state="translated">通过 "function" 关键字的匹配模式和活动模式通常如下所示。</target>
<note />
</trans-unit>
<trans-unit id="PrintParse">
<source>Call the printer with some different values to parse.</source>
<target state="translated">使用一些其他值调用打印机进行分析。</target>
<note />
</trans-unit>
<trans-unit id="Option-Line1">
<source>Option values are any kind of value tagged with either 'Some' or 'None'.</source>
<target state="translated">选项值是用“Some”或“None”标记的任何类型的值。</target>
<note />
</trans-unit>
<trans-unit id="Option-Line2">
<source>They are used extensively in F# code to represent the cases where many other</source>
<target state="translated">它们在 F# 代码中广泛用于表示许多其他</target>
<note />
</trans-unit>
<trans-unit id="Option-Line3">
<source>languages would use null references.</source>
<target state="translated">语言使用 null 引用的用例。</target>
<note />
</trans-unit>
<trans-unit id="Option-Line4">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/options</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/options</target>
<note />
</trans-unit>
<trans-unit id="ZipCode">
<source>First, define a zipcode defined via Single-case Discriminated Union.</source>
<target state="translated">首先，定义通过单用例可区分联合定义的邮政编码。</target>
<note />
</trans-unit>
<trans-unit id="Customer">
<source>Next, define a type where the ZipCode is optional.</source>
<target state="translated">接下来，定义一个类型，其中 ZipCode 是可选项。</target>
<note />
</trans-unit>
<trans-unit id="ShippingCalculator-Line1">
<source>Next, define an interface type that represents an object to compute the shipping zone for the customer's zip code,</source>
<target state="translated">接下来，定义表示对象的接口类型，用于计算客户邮政编码的送货区域，</target>
<note />
</trans-unit>
<trans-unit id="ShippingCalculator-Line2">
<source>given implementations for the 'getState' and 'getShippingZone' abstract methods.</source>
<target state="translated">假定提供了“getState”和“getShippingZone”抽象方法的实现。</target>
<note />
</trans-unit>
<trans-unit id="CalcShippingZone-Line1">
<source>Next, calculate a shipping zone for a customer using a calculator instance.</source>
<target state="translated">接下来，使用计算器实例计算客户的发货区域。</target>
<note />
</trans-unit>
<trans-unit id="CalcShippingZone-Line2">
<source>This uses combinators in the Option module to allow a functional pipeline for</source>
<target state="translated">它在选项模块中使用连接符以允许功能管道</target>
<note />
</trans-unit>
<trans-unit id="CalcShippingZone-Line3">
<source>transforming data with Optionals.</source>
<target state="translated">用于使用可选项转换数据。</target>
<note />
</trans-unit>
<trans-unit id="UnitsOfMeasure-Line1">
<source>Units of measure are a way to annotate primitive numeric types in a type-safe way.</source>
<target state="translated">度量单位是一种以类型安全方式批注基元数值类型的方式。</target>
<note />
</trans-unit>
<trans-unit id="UnitsOfMeasure-Line2">
<source>You can then perform type-safe arithmetic on these values.</source>
<target state="translated">然后，你便可以对这些值执行类型安全算术。</target>
<note />
</trans-unit>
<trans-unit id="UnitsOfMeasure-Line3">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/units-of-measure</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/units-of-measure</target>
<note />
</trans-unit>
<trans-unit id="CommonUnits">
<source>First, open a collection of common unit names</source>
<target state="translated">首先，打开常用单位名称集合</target>
<note />
</trans-unit>
<trans-unit id="DefineUnitConstant">
<source>Define a unitized constant</source>
<target state="translated">定义单元化常量</target>
<note />
</trans-unit>
<trans-unit id="MileUnit">
<source>Next, define a new unit type</source>
<target state="translated">接下来，定义新的单位类型</target>
<note />
</trans-unit>
<trans-unit id="MileToMeter">
<source>Conversion factor mile to meter.</source>
<target state="translated">英里到米的换算系数。</target>
<note />
</trans-unit>
<trans-unit id="DefineMileConstant">
<source>Define a unitized constant</source>
<target state="translated">定义单元化常量</target>
<note />
</trans-unit>
<trans-unit id="ComputeMileToMeter">
<source>Compute metric-system constant</source>
<target state="translated">计算公制常量</target>
<note />
</trans-unit>
<trans-unit id="PrintUnitsOfMeasure">
<source>Values using Units of Measure can be used just like the primitive numeric type for things like printing.</source>
<target state="translated">使用度量单位的值可像基元数值类型用于打印等操作一样直接使用。</target>
<note />
</trans-unit>
<trans-unit id="Classes-Line1">
<source>Classes are a way of defining new object types in F#, and support standard Object-oriented constructs.</source>
<target state="translated">类是 F# 中定义新对象类型的一种方式，且支持标准的面向对象的构造。</target>
<note />
</trans-unit>
<trans-unit id="Classes-Line2">
<source>They can have a variety of members (methods, properties, events, etc.)</source>
<target state="translated">它们可以有各种成员(如，方法、属性、事件等)</target>
<note />
</trans-unit>
<trans-unit id="Classes-Line3">
<source>To learn more about Classes, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/classes</source>
<target state="translated">若要了解关于类的详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/classes</target>
<note />
</trans-unit>
<trans-unit id="Classes-Line4">
<source>To learn more about Members, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/members</source>
<target state="translated">若要深入了解成员，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/members</target>
<note />
</trans-unit>
<trans-unit id="Vector-Line1">
<source>A simple two-dimensional Vector class.</source>
<target state="translated">简单的二维矢量类。</target>
<note />
</trans-unit>
<trans-unit id="Vector-Line2">
<source>The class's constructor is on the first line,</source>
<target state="translated">该类的构造函数位于第一行，</target>
<note />
</trans-unit>
<trans-unit id="Vector-Line3">
<source>and takes two arguments: dx and dy, both of type 'double'.</source>
<target state="translated">并且采用两个参数: dx 和 dy，二者均属于类型 "double"。</target>
<note />
</trans-unit>
<trans-unit id="ClassInternalField-Line1">
<source>This internal field stores the length of the vector, computed when the</source>
<target state="translated">此内部字段存储矢量的长度，当发生以下情况时进行计算:</target>
<note />
</trans-unit>
<trans-unit id="ClassInternalField-Line2">
<source>object is constructed</source>
<target state="translated">对象已构造</target>
<note />
</trans-unit>
<trans-unit id="ThisKeyword-Line1">
<source>'this' specifies a name for the object's self identifier.</source>
<target state="translated">“this”用于指定对象的自我标识符的名称。</target>
<note />
</trans-unit>
<trans-unit id="ThisKeyword-Line2">
<source>In instance methods, it must appear before the member name.</source>
<target state="translated">在实例方法中，它必须出现在成员名称之前。</target>
<note />
</trans-unit>
<trans-unit id="MemberMethod">
<source>This member is a method. The previous members were properties.</source>
<target state="translated">该成员属于方法。以前的成员属于属性。</target>
<note />
</trans-unit>
<trans-unit id="InstantiateClass">
<source>This is how you instantiate the Vector2D class.</source>
<target state="translated">这就是你实例化 Vector2D 类的方式。</target>
<note />
</trans-unit>
<trans-unit id="ScaledVector">
<source>Get a new scaled vector object, without modifying the original object.</source>
<target state="translated">获取新的缩放矢量对象而不修改原始对象。</target>
<note />
</trans-unit>
<trans-unit id="GenericClasses-Line1">
<source>Generic classes allow types to be defined with respect to a set of type parameters.</source>
<target state="translated">通用类允许考虑使用一组类型参数来定义类型。</target>
<note />
</trans-unit>
<trans-unit id="GenericClasses-Line2">
<source>In the following, 'T is the type parameter for the class.</source>
<target state="translated">以下示例中，"T" 表示类的类型参数。</target>
<note />
</trans-unit>
<trans-unit id="GenericClasses-Line3">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/generics/</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/generics/</target>
<note />
</trans-unit>
<trans-unit id="InternalField">
<source>This internal field store the states in a list.</source>
<target state="translated">此内部字段将状态存储在列表中。</target>
<note />
</trans-unit>
<trans-unit id="AddElement">
<source>Add a new element to the list of states.</source>
<target state="translated">将新元素添加到状态列表中。</target>
<note />
</trans-unit>
<trans-unit id="MutableAssignment">
<source>use the '<-' operator to mutate the value.</source>
<target state="translated">使用 "<-" 运算符改变值。</target>
<note />
</trans-unit>
<trans-unit id="History">
<source>Get the entire list of historical states.</source>
<target state="translated">获取历史状态的完整列表。</target>
<note />
</trans-unit>
<trans-unit id="Current">
<source>Get the latest state.</source>
<target state="translated">获取最新状态。</target>
<note />
</trans-unit>
<trans-unit id="InferredTypeParameter">
<source>An 'int' instance of the state tracker class. Note that the type parameter is inferred.</source>
<target state="translated">状态跟踪程序类的一个“int”实例。请注意，已推断类型参数。</target>
<note />
</trans-unit>
<trans-unit id="AddState">
<source>Add a state</source>
<target state="translated">添加状态</target>
<note />
</trans-unit>
<trans-unit id="Interfaces-Line1">
<source>Interfaces are object types with only 'abstract' members.</source>
<target state="translated">接口是只有“抽象”成员的对象类型。</target>
<note />
</trans-unit>
<trans-unit id="Interfaces-Line2">
<source>Object types and object expressions can implement interfaces.</source>
<target state="translated">对象类型和对象表达式可以实现接口。</target>
<note />
</trans-unit>
<trans-unit id="Interfaces-Line3">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/interfaces</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/interfaces</target>
<note />
</trans-unit>
<trans-unit id="IDisposable">
<source>This is a type that implements IDisposable.</source>
<target state="translated">它是实现 IDisposable 的类型。</target>
<note />
</trans-unit>
<trans-unit id="IDisposableImplementation">
<source>This is the implementation of IDisposable members.</source>
<target state="translated">它是 IDisposable 成员的实现。</target>
<note />
</trans-unit>
<trans-unit id="IDisposableObjectExpression-Line1">
<source>This is an object that implements IDisposable via an Object Expression</source>
<target state="translated">该对象可通过对象表达式实现 IDisposable</target>
<note />
</trans-unit>
<trans-unit id="IDisposableObjectExpression-Line2">
<source>Unlike other languages such as C# or Java, a new type definition is not needed</source>
<target state="translated">与 C# 或 Java 等其他语言不同，无需新的类型定义</target>
<note />
</trans-unit>
<trans-unit id="IDisposableObjectExpression-Line3">
<source>to implement an interface.</source>
<target state="translated">以实现接口。</target>
<note />
</trans-unit>
<trans-unit id="Parallel-Line1">
<source>The FSharp.Core library defines a range of parallel processing functions. Here</source>
<target state="translated">FSharp.Core 库定义了一系列并行处理函数。此处</target>
<note />
</trans-unit>
<trans-unit id="Parallel-Line2">
<source>you use some functions for parallel processing over arrays.</source>
<target state="translated">可使用某些函数对数组进行并行处理。</target>
<note />
</trans-unit>
<trans-unit id="Parallel-Line3">
<source>To learn more, see: https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/array.parallel-module-%5Bfsharp%5D</source>
<target state="translated">有关详细信息，请参阅: https://msdn.microsoft.com/zh-cn/visualfsharpdocs/conceptual/array.parallel-module-%5Bfsharp%5D</target>
<note />
</trans-unit>
<trans-unit id="InputArray">
<source>First, an array of inputs.</source>
<target state="translated">首先，输入一个数组。</target>
<note />
</trans-unit>
<trans-unit id="ExpensiveFunction">
<source>Next, define a functions that does some CPU intensive computation.</source>
<target state="translated">接下来，定义执行某些 CPU 密集型计算的函数。</target>
<note />
</trans-unit>
<trans-unit id="ParallelMap">
<source>Next, do a parallel map over a large input array.</source>
<target state="translated">接下来，对大型输入数组执行并行映射。</target>
<note />
</trans-unit>
<trans-unit id="PrintParallel">
<source>Next, print the results.</source>
<target state="translated">接下来，打印结果。</target>
<note />
</trans-unit>
<trans-unit id="Events-Line1">
<source>Events are a common idiom for .NET programming, especially with WinForms or WPF applications.</source>
<target state="translated">事件是 .NET 编程的常见习惯用语，尤其是使用 WinForms 或 WPF 应用程序编程时。</target>
<note />
</trans-unit>
<trans-unit id="Events-Line2">
<source>To learn more, see: https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/members/events</source>
<target state="translated">有关详细信息，请参阅: https://docs.microsoft.com/zh-cn/dotnet/articles/fsharp/language-reference/members/events</target>
<note />
</trans-unit>
<trans-unit id="SimpleEvent">
<source>First, create instance of Event object that consists of subscription point (event.Publish) and event trigger (event.Trigger).</source>
<target state="translated">首先，创建包含订阅点(event.Publish)和事件触发器(event.Trigger)的事件对象实例。</target>
<note />
</trans-unit>
<trans-unit id="AddEventHandler1">
<source>Next, add handler to the event.</source>
<target state="translated">接下来，将处理程序添加到事件。</target>
<note />
</trans-unit>
<trans-unit id="TriggerEvent">
<source>Next, trigger the event.</source>
<target state="translated">接下来，触发该事件。</target>
<note />
</trans-unit>
<trans-unit id="EventWithArgs">
<source>Next, create an instance of Event that follows standard .NET convention: (sender, EventArgs).</source>
<target state="translated">接下来，创建遵循标准 .NET 约定的事件的实例: (sender, EventArgs)。</target>
<note />
</trans-unit>
<trans-unit id="AddEventHandler2">
<source>Next, add a handler for this new event.</source>
<target state="translated">接下来，为此新事件添加处理程序。</target>
<note />
</trans-unit>
<trans-unit id="TriggerEventWithArgs">
<source>Next, trigger this event (note that sender argument should be set).</source>
<target state="translated">接下来，触发此事件(请注意，应设置 sender 参数)。</target>
<note />
</trans-unit>
</body>
</file>
</xliff>