我一直试图进入Fon并离开一段时间，但我一直被推迟。为什么？

因为无论尝试使用哪个"入门"资源，我都看到了非常简单的示例，这些示例开始使用运算符->。

但是，到目前为止，我还没有找到关于此运算符含义的简单明了的解释。好像必须是如此明显，以至于即使是新手也不需要解释。

因此，我必须非常专心，否则可能是过去将近30年的经历使我退缩了。

有人可以解释它，还是指向一个真正可访问的资源对其进行解释？

解决方案

它的基本意思是"映射到"。以这种方式或者"转化为"或者类似方式阅读。

因此，从Fin 20分钟教程中，

> List.map (fun x -> x % 2 = 0) [1 .. 10];;
val it : bool list
= [false; true; false; true; false; true; false; true; false; true]

The code (fun i -> i % 2 = 0) defines
  an anonymous function, called a lambda
  expression, that has a parameter x and
  the function returns the result of "x
  % 2 = 0", which is whether or not x is
  even.

从Microsoft：

Function types  are the types given to
  first-class function values and are
  written int -> int. They are similar
  to .NET delegate types, except they
  aren't given names. All F# function
  identifiers can be used as first-class
  function values, and anonymous
  function values can be created using
  the (fun ... -> ...) expression form.

(a-> b)表示"从a到b的功能"。在类型注释中，它表示功能类型。例如，f：(int-> String)表示f引用一个接受整数并返回字符串的函数。它也用作此类值的构造函数，例如

val f : (int -> int) = fun n -> n * 2

它创建一个值，该值是从某个数字n到同一数字乘以2的函数。

关于诸如Haskell之类的语言(在F＃中非常相似，但我不知道确切的语法-这应该有助于我们理解->)的好处是，我们只能应用部分参数来创建咖喱函数：

adder n x y = n + x + y

换句话说："给我三件事，我将它们加在一起"。当我们向其扔数字时，编译器将推断n x和y的类型。说你写

adder 1 2 3

1、2和3的类型是Int。所以：

adder :: Int -> Int -> Int -> Int

也就是说，给我三个整数，最终我将成为一个整数，或者与说的一样：

five :: Int
five = 5

但是，这是不错的部分！试试这个：

add5 = adder 5

我们还记得，加法器接受一个int，一个int，一个int并给我们一个int。但是，这并不是全部事实，我们很快就会看到。实际上，add5将具有以下类型：

add5 :: Int -> Int -> Int

就像我们已经"剥离"了整数(最左侧)，并将其直接粘合到函数上一样。仔细查看函数签名，我们注意到->是右关联的，即：

addder :: Int -> (Int -> (Int -> Int))

这应该很清楚：给加法器第一个整数时，它将求出第一个箭头右边的内容，或者：

add5andtwomore :: Int -> (Int -> Int)
add5andtwomore = adder 5

现在，我们可以使用add5andtwomore代替" adder 5"。这样，我们可以应用另一个整数来获取(例如)" add5and7andonemore"：

add5and7andonemore :: Int -> Int
add5and7andonemore = adder 5 7

如我们所见，add5and7andonemore恰好需要另一个参数，当我们给它一个参数时，它将突然变成整数！

> add5and7andonemore 9
 => ((add5andtwomore) 7) 9
 => ((adder 5) 7) 9)
<=> adder 5 7 9

将参数替换为(5 7 9)的加法器(n x y)，我们得到：

> adder 5 7 9 = 5 + 7 + 9
 => 5 + 7 + 9
 => 21

实际上，plus也是一个接受一个int并返回另一个int的函数，因此上面的内容实际上更像是：

> 5 + 7 + 9
 => (+ 5 (+ 7 9))
 => (+ 5 16)
 => 21

你去！

这里已经有很多不错的答案，我只是想在对话中加入另一种思考方式。

'->'表示功能。

'a->'b是一个接受'a并返回'b的函数

('a *'b)->('c *'d)是一个接受('a，'b)类型的元组并返回('c，'d)元组的函数。如int / string返回float / char。

有趣的地方是'a->'b->'c的级联情况。这是一个采用'a并返回一个函数('b->'c)的函数，或者是采用'b->'c的函数。

因此，如果我们写：
令f x y z =()

类型将为f：'a->'b->'c-> unit，因此，如果仅应用第一个参数，则结果将为咖喱函数'b->'c->'unit。

在定义函数的上下文中，它类似于C3.0中lambda表达式中的" =>"。

F#: let f = fun x -> x*x
C#: Func<int, int> f = x => x * x;

Fis中的->也用于模式匹配，这表示：如果表达式匹配|和->之间的部分，则应返回->之后的内容：

let isOne x = match x with
 | 1 -> true
 | _ -> false

第一个问题我们熟悉C＃中的lambda表达式吗？如果是这样，则Fis中的->与C中的=>相同(我认为我们读过它"是")。

->运算符也可以在模式匹配的上下文中找到

match x with
| 1 -> dosomething
| _ -> dosomethingelse

我不确定这是否也是lambda表达式或者其他表达式，但我想"继续"仍然成立。

也许我们真正指的是Fparser的"神秘"回应：

> let add a b = a + b
val add: int -> int -> int

这意味着(如大多数示例所述)，add是一个" val"，它接受两个int并返回一个int。在我看来，这完全是不透明的。我的意思是，我怎么知道add不是一个需要一个int并返回两个int的val？

好吧，从某种意义上说，事实确实如此。如果我只添加一个int，则返回一个(int-> int)：

> let inc = add 1
val inc: int -> int

对我来说，这(令人毛骨悚然)是让Fso性感的原因之一。

有关F＃的有用信息，我发现博客比任何正式的"文档"都更有用：这是一些要检查的名称

• 达斯汀·坎贝尔(那是diditwith.net，在另一个答案中引用)
• 唐·塞梅斯('the'man)
• Tomasp.net(又名Tomas Petricek)
• 安德鲁·肯尼迪(计量单位)
• Fsharp.it(以Euler项目解决方案而闻名)
• http://lorgonblog.spaces.live.com/Blog(又名Brian)
• 乔莫·费舍尔

'->'不是运算符。它出现在Fsyntax中的许多地方，其含义取决于如何将其用作较大结构的一部分。

在类型内部，"->"描述了如上所述的函数类型。例如

let f : int -> int = ...

说'f'是一个接受一个int并返回一个int的函数。

在lambda("以'fun'关键字开头的东西")内部，'->'是将参数与主体分开的语法。例如

fun x y -> x + y + 1

是使用给定实现定义两个参数函数的表达式。

在" match"构造中，"->"是一种语法，用于将模式与如果模式匹配则应运行的代码分开。例如，在

match someList with
| [] -> 0
| h::t -> 1

每个'->'左边的内容是模式，右边的内容是如果匹配了左边的模式会发生什么。

理解上的困难可能源于错误的假设，即"->"是具有单一含义的"运算符"。打个比方可能是"。"在C＃中，如果我们以前从未看过任何代码，请尝试分析"。"基于" obj.Method"，" 3.14"和" System.Collections"的运算符，我们可能会感到非常困惑，因为该符号在不同的上下文中具有不同的含义。但是，一旦我们掌握了足以识别这些上下文的语言，一切就会变得清晰起来。

谢谢大家，对这个问题有很多很好的答案。我想在这里提出一个可编辑的答案，将所有内容整合在一起。

对于熟悉Cunderstanding->与=> lamba表达式相同的人来说，这是一个很好的第一步。这种用法是：-

fun x y -> x + y + 1

可以理解为等同于：

(x, y) => x + y + 1;

但是，显然->具有更基本的含义，其源于这样的概念：可以将采用上述两个参数的函数简化为(是正确的术语？)为仅采用一个参数的一系列函数。

因此，当以这样的方式描述以上内容时：

Int -> Int -> Int

知道->是正确的关联真的很有帮助，因此可以考虑上述内容：-

Int -> (Int -> Int)

啊哈！我们有一个接受Int并返回(Int-> Int)的函数(一个咖喱函数？)。

->也可以作为定义类型的一部分出现的解释也有所帮助。 (Int-> Int)是采用Int并返回Int的任何函数的类型。

->以其他语法(例如匹配)出现也很有帮助，但那里没有相同的含义吗？那是对的吗？我不确定是这样。我怀疑它的含义相同，但我还没有表达它的词汇。

请注意，此答案的目的不是生成更多答案，而是由我们进行协作编辑以创建更明确的答案。从总体上讲，最好删除所有不确定性和起伏(例如本段)，并添加更好的示例。让我们尝试使这个答案尽可能让未开始的人访问。