blocks|key|1131711|text|不幸的是，不，你不能。::不是一个操作符，而是一个根据语言语法的“符号关键字”(参见3.6+of+the+spec小节)，就像:?>和其他一些人一样。然而，这种语言在这里似乎并不完全一致，因为有一些符号关键字可以被视为操作符(至少是(*)和(<@+@>))。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1131712|entityMap|0|LINK|mutability|MUTABLE|url|http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/spec.html#_Toc270597389^0|B|2|1R|3|38|3|3C|7|16|F|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@$9|W|A|X|1|Y]]|E|$]]|$1|F|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Unfortunately, no, you can't. <code>::</code> is not an operator, but a "symbolic keyword" according to the language grammar (see section <a href="http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/manual/spec.html#_Toc270597389" rel="noreferrer">3.6 of the spec</a>), as are <code>:?&gt;</code> and a few others. The language doesn't seem completely consistent here, though, since there are a few symbolic keywords which can be treated as though they were operators (at least <code>(*)</code> and <code>(&lt;@ @&gt;)</code>).

blocks|key|917036|text|::和[]都可以分别用List<_>.Cons和List<_>.Empty表示。但请记住，前者将元组作为参数。这里列出了这些列表，以便可以用F#以外的语言创建列表。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|917037|>+List.Cons(4,+List.Empty);;
val+it+:+int+list+=+[4]

>+4::[];;
val+it+:+int+list+=+[4]

>+List<int>.Cons(4,+List<int>.Empty);;
val+it+:+int+list+=+[4]

>+List.Cons;;
val+it+:+'a+*+'a+list+->+'a+list+=+<fun:clo@24-7>+//'

>+List<int>.Empty;;
val+it+:+int+list+=+[]|code-block|syntax|javascript|917038|entityMap^0|0|2|3|2|B|C|O|D|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|L|$]]

<code>::</code> and <code>[]</code> can both be represented by <code>List&lt;_&gt;.Cons</code> and <code>List&lt;_&gt;.Empty</code> respectively. Keep in mind though that the former takes a tuple as an argument. These are here so lists can be created in languages other than F#.

<pre><code>&gt; List.Cons(4, List.Empty);;
val it : int list = [4]

&gt; 4::[];;
val it : int list = [4]

&gt; List&lt;int&gt;.Cons(4, List&lt;int&gt;.Empty);;
val it : int list = [4]

&gt; List.Cons;;
val it : 'a * 'a list -&gt; 'a list = &lt;fun:clo@24-7&gt; //'

&gt; List&lt;int&gt;.Empty;;
val it : int list = []
</code></pre>

blocks|key|917093|text|改写自http://cs.hubfs.net/forums/permalink/11713/11713/ShowThread.aspx#11713|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|917094|(::)是list<'a>+type的一个有区别的联合“构造函数”，因此提出了一个问题:作为函数值，它的参数应该是curried+(像%2B一样)还是tupled+(像所有DU构造函数一样)。对于某些人来说，这两种方式似乎都很可疑/意想不到，所以F#干脆不允许这种构造。|style|CODE|917095|当然，你也可以这样写。|917096|let+cons+x+y+=+x+::+y|code-block|syntax|javascript|917097|使用cons，或者只使用一个lambda+fun+x+y+->+x::y，如果你想要一个“两个参数的curried前缀函数”。|917098|entityMap|0|LINK|mutability|MUTABLE|url|http://cs.hubfs.net/forums/permalink/11713/11713/ShowThread.aspx#11713^0|3|1Y|0|0|0|4|5|D|1V|1|0|0|0|2|4|L|F|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|6|7|12|8|@$A|13|B|14|F|G]|$A|15|B|16|F|G]|$A|17|B|18|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|19|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|1A|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1B|8|@$A|1C|B|1D|F|G]|$A|1E|B|1F|F|G]]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

Paraphrased from <a href="http://cs.hubfs.net/forums/permalink/11713/11713/ShowThread.aspx#11713" rel="nofollow noreferrer">http://cs.hubfs.net/forums/permalink/11713/11713/ShowThread.aspx#11713</a>

<code>(::)</code> is a discriminated union 'constructor' for the <code>list&lt;'a&gt; type</code>, and so raised the question of whether as a function value its arguments should be curried (like <code>+</code>) or tupled (like all DU constructors). Either way seems fishy/unexpected to some people, so F# simply disallows the construct.

Of course you can always write e.g.

<pre><code>let cons x y = x :: y
</code></pre>

and use <code>cons</code>, or just use a lambda <code>fun x y -&gt; x::y</code>, if you want a "curried prefix function of two args" for this.

F# lets you turn operators into functions by surrounding them with <code>(</code> <code>)</code>: for instance, <code>(+)</code> is of type <code>int -&gt; int -&gt; int</code>.

Is it possible to do this with the list cons operator, <code>::</code>?

It doesn't behave like a normal binary operator:

<pre><code>FSI&gt; (::);;

 (::);;
 -^^

c:\temp\stdin(3,2): error FS0010: Unexpected symbol '::' in expression.
Expected ')' or other token.
</code></pre>

And the <code>List.Cons</code> method takes a tuple; it's not curried.

(It's useful to be able to do this. For instance, you can use it to implement <a href="http://www.haskell.org/haskellwiki/Fold" rel="noreferrer">map in terms of fold</a>).

Use list cons operator (a :: b) as a function

F#允许您通过使用( )将运算符转换为函数:例如，(+)的类型为int -> int -> int。是否可以使用list cons运算符::执行此操作它的行为与普通的二元运算符不同：FSI> (::);;  (::);;  -^^c:\temp\stdin(3,2): error FS0010: Unexpected ...

问使用list cons运算符(a :：b)作为函数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用list cons运算符(a :：b)作为函数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用list cons运算符(a :：b)作为函数
EN