本主题包含一个表,其中列出了 F# 语言中使用的符号和运算符。                   



符号和运算符表            



            

          

下表描述了 F# 语言中使用的符号,提供了包含更多信息的主题的链接,还提供了有关某些符号用法的简要说明。               这些符号根据 ASCII 字符集顺序进行了排序。 


 



符号或运算符                                       



链接                                       



描述                                       



!                                       



​引用单元格 (F#)​​                                       

​计算表达式 (F#)​​                                       



  • 取消对引用单元格的引用。                                               
  • 用在一个关键字之后,指示该关键字的行为的修改版本(由一个工作流控制)。                                               



!=                                       



不适用。                                       



  • F# 中未使用。                           将 <> 用于不等运算。 



"                                       



​文本 (F#)​​                                       

​字符串 (F#)​​                                       



  • 分隔文本字符串。                                               



"""                                       



​字符串 (F#)​​                                       



分隔原义文本字符串。                       与 @"..." 的不同之处在于通过在该字符串,的一个单引号您可以指示引号字符。 



#                                       



​编译器指令 (F#)​​                                       

​可变类型 (F#)​​                                       



  • 为预处理器或编译器指令添加前缀,如 #light。                                               
  • 在与某个类型一起使用时,指示一个可变类型,该类型引用一个类型或其任一派生类型。                                               



$                                       



未提供更多信息。                                       



  • 在内部用于某些编译器生成的变量和函数名称。                                               



%                                       



​算术运算符 (F#)​​                                       

​代码引用 (F#)​​                                       



  • 计算整数模数。                           用于接合引用。 



%?                                       



​可以为 null 的运算符 (F#)​​                                       



在右侧是可以为 null 的类型时,计算整数模数。                                       



&                                       



​match 表达式 (F#)​​                                       



  • 计算可变值的地址,以便在与其他语言进行互操作时使用。                                               
  • 在“与”模式中使用。                                               



&&                                       



​布尔运算符 (F#)​​                                       



  • 计算布尔“与”运算。                                               



&&&                                       



​位运算符 (F#)​​                                       



  • 计算按位“与”运算。                                               



'                                       



​文本 (F#)​​                                       

​自动泛化 (F#)​​                                       



  • 分隔单字符文本。                                               
  • 指示泛型类型参数。                                               



``...``                                       



未提供更多信息。                                       



  • 分隔一个标识符(如果不进行分隔,则它不是合法的标识符,例如一个语言关键字)。                                               



( )                                       



​unit 类型 (F#)​​                                       



  • 表示单元类型的单个值。                                               



(...)                                       



​元组 (F#)​​                                       

​运算符重载 (F#)​​                                       



  • 指示计算表达式的顺序。                                               
  • 分隔元组。                                               
  • 在运算符定义中使用。                                               



(*...*)                                       


 


  • 分隔可跨多行的注释。                                               



(|...|)                                       



​活动模式 (F#)​​                                       



  • 分隔活动模式。                           也称作“香蕉夹”。 



*                                       



​算术运算符 (F#)​​                                       

​元组 (F#)​​                                       

​度量单位 (F#)​​                                       



  • 在用作二元运算符时,将左侧数字与右侧数字相乘。                                               
  • 在类型中,指示在元组中配对。                                               
  • 在度量单位类型中使用。                                               



*?                                       



​可以为 null 的运算符 (F#)​​                                       


  1. 在右侧是可以为 null 的类型时,将左侧数字与右侧数字相乘。                                               


**                                       



​算术运算符 (F#)​​                                       



  • 计算求幂运算(x ** y 表示 x 的 y 次幂)。                                               



+                                       



​算术运算符 (F#)​​                                       



  • 在用作二元运算符时,将左侧数字与右侧数字相加。                                               
  • 在用作一元运算符时,指示正数量。                           (从形式上看,它会生成符号不变的相同值。) 



+?                                       



​可以为 null 的运算符 (F#)​​                                       


  1. 在右侧是可以为 null 的类型时,将左侧数字与右侧数字相加。                                               


,                                       



​元组 (F#)​​                                       



  • 分隔元组元素或类型参数。                                               



-                                       



​算术运算符 (F#)​​                    



  • 在用作二元运算符时,将从左侧数字减去右侧数字。                                               
  • 在用作一元运算符时,执行求反运算。                                               



-                                       



​可以为 null 的运算符 (F#)​​                                       


  1. 在右侧是可以为 null 的类型时,从左侧数字减去右侧。                                               


->                                       



​函数 (F#)​​                                       

​match 表达式 (F#)​​                                       



  • 在函数类型中,分隔参数和返回值。                                               
  • 生成一个表达式(在序列表达式中);与 yield 关键字等效。                                               
  • 在匹配表达式中使用                                               



.                                       



​成员 (F#)​​                                       

​基元类型 (F#)​​                                       



  • 访问一个成员,并用完全限定名称分隔各个名称。                                               
  • 指定浮点数中的小数点。                                               



..                                       



​循环:for...in 表达式 (F#)​​                                       



  • 指定一个范围。                                               



.. ..                                        



​循环:for...in 表达式 (F#)​​                                       



  • 指定一个范围和一个增量。                                               



.[...]                                       



​数组 (F#)​​                                       



  • 访问一个数组元素。                                               



/                                       



​算术运算符 (F#)​​                                       

​度量单位 (F#)​​                                       



  • 用左侧数字(分子)除以右侧数字(分母)。                                               
  • 在度量单位类型中使用。                                               



/?                                       



​可以为 null 的运算符 (F#)​​                                       


  1. 在右侧是可以为 null 的类型时,由右侧部件左侧。                                               


//                                       


 


  • 指示单行注释的开头。                                               



///                                       



​XML 文档 (F#)​​                                       



  • 指示 XML 注释。                                               



:                                       



​函数 (F#)​​                                       



  • 在类型注释中,将参数或成员名称与其类型分离。                                               



::                                       



​列表 (F#)​​                                       

​match 表达式 (F#)​​                                       



  • 创建一个列表。                           将左侧的元素追加到右侧的列表中。 
  • 在模式匹配中使用以分隔列表的各个部分。                                               



:=                                       



​引用单元格 (F#)​​                                       



  • 给引用单元格赋值。                                               



:>                                       



​强制转换和转换 (F#)​​                                       



  • 将一个类型转换为层次结构中更高层的类型。                                               



:?                                       



​match 表达式 (F#)​​                                       



  • 如果值与指定的类型匹配,则返回 true;否则,返回 false(类型测试运算符)。                                               



:?>                                       



​强制转换和转换 (F#)​​                                       



  • 将一个类型转换为层次结构中更低层的类型。                                               



;                                       



​详细语法 (F#)​​                                       

​列表 (F#)​​                                       

​记录 (F#)​​                                       



  • 分隔表达式(通常在详细语法中使用)。                                               
  • 分隔列表元素。                                               
  • 分隔记录字段。                                               



<                                       



​算术运算符 (F#)​​                                       



  • 计算小于运算。                                               



<?                                       



​可以为 null 的运算符 (F#)​​                                       



在右侧是可以为 null 的类型时,与运算更少。                                       



<<                                       



​函数 (F#)​​                                       



  • 按照相反的顺序组合两个函数;首先执行第二个函数(后向组合运算符)。                                               



<<<                                       



​位运算符 (F#)​​                                       



  • 将左侧数量中的位左移右侧指定的位数。                                               



<-                                       



​值 (F#)​​                                       



  • 给变量赋值。                                               



<...>                                       



​自动泛化 (F#)​​                                       



  • 分隔类型参数。                                               



<>                                       



​算术运算符 (F#)​​                                       



  • 如果左侧的数字不等于右侧的数字,则返回 true;否则返回 false。                                               



<>?                                       



​可以为 null 的运算符 (F#)​​                                       


  1. 在右侧是可以为 null 的类型时,计算“不等于”操作。                                               


<=                                       



​算术运算符 (F#)​​                                       



  • 如果左侧的数字小于或等于右侧的数字,则返回 true;否则返回 false。                                               



<=?                                       



​可以为 null 的运算符 (F#)​​                                       


  1. 在右侧是可以为 null 的类型时,计算“小于或等于”操作。                                               


<|                                       



​函数 (F#)​​                                       



  • 将右侧表达式的结果传递给左侧的函数(后向管道运算符)。                                               



<||                                       



​Operators.( <|| )<'T1,'T2,'U> 函数 (F#)​​                                       



  • 传递两个参数元组右侧的传递给左侧的功能。                                               



<|||                                       



​Operators.( <||| )<'T1,'T2,'T3,'U> 函数 (F#)​​                                       



  • 通过三个参数元组右侧的传递给左侧的功能。                                               

 



<@...@>                                       



​代码引用 (F#)​​                                       



  • 分隔类型化代码引用。                                               



<@@...@@>                                       



​代码引用 (F#)​​                                       



  • 分隔非类型化的代码引用。                                               



=                                       



​算术运算符 (F#)​​                                       



  • 如果左侧的数字等于右侧的数字,则返回 true;否则返回 false。                                               



=?                                       



​可以为 null 的运算符 (F#)​​                                       


  1. 在右侧是可以为 null 的类型时,计算“相等”操作。                                               


==                                       



不适用。                                       



  • F# 中未使用。                           将 = 用于相等运算。 



>                                       



​算术运算符 (F#)​​                                       



  • 如果左侧的数字大于右侧的数字,则返回 true;否则返回 false。                                               



>?                                       



​可以为 null 的运算符 (F#)​​                                       


  1. 在右侧是可以为 null 的类型时,与”运算“greather。                                               


>>                                       



​函数 (F#)​​                                       



  • 组合两个函数(前向组合运算符)。                                               



>>>                                       



​位运算符 (F#)​​                                       



  • 将左侧数量中的位右移右侧指定的位数。                                               



>=                                       



​算术运算符 (F#)​​                                       



  • 如果右侧的数字大于或等于左侧的数字,则返回 true;否则返回 false。                                               



>=?                                       



​可以为 null 的运算符 (F#)​​                                       


  1. 在右侧是可以为 null 的类型时,计算“大于或等于”操作。                                               


?                                       



​形参和实参 (F#)​​                                       



  • 指定可选参数。                                               
  • 用作动态方法和属性调用的运算符。                           必须提供自己的实现。 



? ... <- ...                                        



未提供更多信息。                                       



  • 用作设置动态属性的操作符。                           必须提供自己的实现。 



?>=   , ?>, ?<=, ?<, ?=, ?<>, ?+, ?-, ?*, ?/                                       



​可以为 null 的运算符 (F#)​​                                       


  1. 为相应的运算符的等效没有?                           前缀,可以为 null 的类型之一在左侧。 


>=?   , >?, <=?, <?, =?, <>?, +?, -?, *?, /?                                       



​可以为 null 的运算符 (F#)​​                                       


  1. 为相应的运算符的等效没有?                           作为后缀,可以为 null 的类型之一在右侧。 


?>=?   , ?>?, ?<=?, ?<?, ?=?, ?<>?, ?+?, ?-?, ?*?, ?/?                                       



​可以为 null 的运算符 (F#)​​                                       


  1. 为相应的运算符的等效没有周围的问号,两边是可以为 null 的类型。                                               


@                                       



​列表 (F#)​​                                       

​字符串 (F#)​​                                       



  • 串联两个列表。                                               
  • 当置于一个字符串文本之前时,指示将对该字符串逐字解释,并且没有任何转义字符的解释。                                               



[...]                                       



​列表 (F#)​​                                       



  • 分隔列表元素。                                               



[|...|]                                       



​数组 (F#)​​                                       



  • 分隔数组元素。                                               



[<...>]                                       



​特性 (F#)​​                                       



  • 分隔特性。                                               



\                                       



​字符串 (F#)​​                                       



  • 对下一个字符进行转义;在字符和字符串文本中使用。                                               



^                                       



​静态解析的类型参数 (F#)​​                                       

​字符串 (F#)​​                                       



  • 指定必须在编译时而不是运行时解析的类型参数。                                               
  • 串联字符串。                                               



^^^                                       



​位运算符 (F#)​​                                       



  • 计算按位“异或”运算。                                               



_                                       



​match 表达式 (F#)​​                                       

​泛型 (F#)​​                                       



  • 指示通配符模式。                                               
  • 指定匿名泛型参数。                                               



`                                       



​自动泛化 (F#)​​                                       



  • 在内部用于指示泛型类型参数。                                               



{...}                                       



​序列 (F#)​​                                       

​记录 (F#)​​                                       



  • 分隔序列表达式和计算表达式。                                               
  • 在记录定义中使用。                                               



|                                       



​match 表达式 (F#)​​                                       



  • 分隔各个匹配用例、各个可区分联合用例以及枚举值。                                               



||                                       



​布尔运算符 (F#)​​                                       



  • 计算布尔“或”运算。                                               



|||                                       



​位运算符 (F#)​​                                       



  • 计算按位“或”运算。                                               



|>                                       



​函数 (F#)​​                                       



  • 将左侧的结果传递给右侧的函数(前向管道运算符)。                                               



||>                                       



​Operators.( ||> )<'T1,'T2,'U> 函数 (F#)​​                                       



  • 传递两个参数元组左侧的传递给右侧的功能。                                               

 



|||>                                       



​Operators.( |||> )<'T1,'T2,'T3,'U> 函数 (F#)​​                                       



  1. 通过三个参数元组左侧的传递给右侧的功能。                                               

 



~~                                       



​运算符重载 (F#)​​                                       



  • 用于声明一元求反运算符的重载。                                               



~~~                                       



​位运算符 (F#)​​                                       



  • 计算按位“非”运算。                                               



~-                                       



​运算符重载 (F#)​​                                       



  • 用于声明一元减号运算符的重载。                                               



~+                                       



​运算符重载 (F#)​​                                       



  • 用于声明一元加号运算符的重载。                                               




运算符优先级            



            

          

下表显示 F# 语言中的运算符和其他表达式关键字的优先级顺序(按照从最低优先级到最高优先级的顺序)。               此外,还列出了结合性(如果适用)。 


 



运算符                                       



结合性                                       



as                                       



Right                                        



when                                       



Right                                        



|                                          (管道)                                       



Left                                        



;                                       



Right                                        



let                                       



不可结合                                       



function   , fun, match, try                                       



不可结合                                       



if                                       



不可结合                                       



->                                       



Right                                        



:=                                       



Right                                        



,                                       



不可结合                                       



or   , ||                                       



Left                                        



&   , &&                                       



Left                                        



<      op, >op, =,                                          |                                          op, &op                                       



Left                                        



&&&   , |||, ^^^, ~~~, <<<, >>>                                       



Left                                        



^      op                                        



Right                                        



::                                       



Right                                        



:?>   , :?                                       



不可结合                                       



-      op、+op(二元)                                       



Left                                        



*      op, /op, %op                                       



Left                                        



**      op                                        



Right                                        



f x   (函数应用程序)                                       



Left                                        



|                                          (模式匹配)                                       



Right                                        



前缀运算符(+op、-op、%、%%、&、&&、!op、~op)                                       



Left                                        



.                                       



Left                                        



f(x)                                       



Left                                        



f<      types   >                                          



Left                                        



F# 支持自定义运算符重载。               这就意味着您可以定义自己的运算符。  在上表中,op 可以是任何有效的运算符字符序列(可能为空),而不论运算符字符是内置的还是用户定义的。  因此,您可以使用此表来确定为自定义运算符使用什么样的字符序列,以实现所需的优先级级别。  当编译器确定优先级时,将忽略前导 . 字符。 



请参见