blocks|key|267711|text|构造函数名称需要在语法上与变量/函数名称不同，以区分模式匹配中的变量和构造函数。示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|267712|f+(Foo+bar)+Baz+bay+=+bar+%2B+bay|code-block|syntax|javascript|267713|在这里，Haskell知道Foo和Baz是它应该匹配的构造函数，而bar和bay是它应该引入的变量，因为它们的大写方式。|offset|length|style|CODE|267714|entityMap^0|0|0|D|3|H|3|X|3|11|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|N|$]]

Constructor names need to be syntactically different from variable/function names to differentiate between variables and constructors in pattern matches. Example:

<pre><code>f (Foo bar) Baz bay = bar + bay
</code></pre>

Here Haskell knows that <code>Foo</code> and <code>Baz</code> are constructors it should match against and <code>bar</code> and <code>bay</code> are variables it should introduce because of the way they are capitalized.

blocks|key|269486|text|从Haskell+98+Language中，我们可以看到Haskell中标识符令牌的核心区别：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|269487|varid+++->+++(small+{small+%7C+large+%7C+digit+%7C+'+})<reservedid>
conid+++->+++large+{small+%7C+large+%7C+digit+%7C+'+}|code-block|syntax|javascript|269488|也就是说，在语言的所有级别(值和类型变量和构造函数)，语言从根本上区分变量名("varid")和构造函数名("conid")。显然，Haskell将标识符区分为两个主要名称空间(如果计算模块和类，还有其他名称空间)，但有两个主要名称空间，以小写字母开头的名称空间(变量标识符)和以大写字母开头的名称空间(构造器标识符)。|269489|因此，鉴于我们确实区分了构造函数和变量，问题是“为什么？”|269490|阅读类型|269491|一个看似合理的论点是，它使得在类型中发现参数(例如，多态类型)变得非常容易。|269492|模式匹配|269493|其次，也是更重要的是，我们有用于数据构造和解构(模式匹配)的统一语法。当您在模式中看到大写标识符时，|269494|case+x+of
+++Foo+y+z+->+...|269495|您知道，Foo是一个被拆分的数据结构，它的组件被命名。相应地，当您在表达式中看到大写标识符时，|style|CODE|269496|g+(f+(Foo+1+2)|269497|您知道，f正在接收一个新构建的带有两个参数的Foo数据类型。|269498|因此，由于构造函数(类型和值)在语言中非常重要，这种对大写标识符的简单限制使人们更容易看到一段代码中发生了什么。在某种程度上，大写字母弥补了语言中其他语法噪音的不足，有助于读者阅读。|269499|269500|命名空间|269501|269502|在Haskell中有六种名称:变量和构造函数的名称表示值；类型变量、类型构造函数和类型类的名称表示与类型系统相关的实体；模块名称表示模块。命名有两个限制：|blockquote|269503|269504|变量和类型变量的名称是以小写字母或下划线开头的标识符；其他四种名称是以大写字母开头的标识符。标识符不能用作同一作用域中的类型构造函数和类的名称。这些是唯一的约束；例如，Int可以同时是单个作用域中的模块、类和构造函数的名称。|269505|269506|Haskell+B|269507|在Haskell+B中，构造函数和变量可以使用任何一种大小写。|269508|entityMap|0|LINK|mutability|MUTABLE|url|http://www.haskell.org/onlinereport/^0|1|J|0|0|0|0|0|0|0|0|0|0|4|3|0|0|4|1|M|3|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1T|8|@]|9|@$A|1U|B|1V|1|1W]]|C|$]]|$1|D|3|E|5|F|7|1X|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|1Z|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|20|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|21|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|22|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|23|8|@]|9|@]|C|$]]|$1|U|3|V|5|F|7|24|8|@]|9|@]|C|$G|H]]|$1|W|3|X|5|6|7|25|8|@$A|26|B|27|Y|Z]]|9|@]|C|$]]|$1|10|3|11|5|F|7|28|8|@]|9|@]|C|$G|H]]|$1|12|3|13|5|6|7|29|8|@$A|2A|B|2B|Y|Z]|$A|2C|B|2D|Y|Z]]|9|@]|C|$]]|$1|14|3|15|5|6|7|2E|8|@]|9|@]|C|$]]|$1|16|3|-4|5|6|7|2F|8|@]|9|@]|C|$]]|$1|17|3|18|5|6|7|2G|8|@]|9|@]|C|$]]|$1|19|3|-4|5|6|7|2H|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|1C|7|2I|8|@]|9|@]|C|$]]|$1|1D|3|-4|5|6|7|2J|8|@]|9|@]|C|$]]|$1|1E|3|1F|5|6|7|2K|8|@]|9|@]|C|$]]|$1|1G|3|-4|5|6|7|2L|8|@]|9|@]|C|$]]|$1|1H|3|1I|5|6|7|2M|8|@]|9|@]|C|$]]|$1|1J|3|1K|5|6|7|2N|8|@]|9|@]|C|$]]|$1|1L|3|-4|5|6|7|2O|8|@]|9|@]|C|$]]]|1M|$1N|$5|1O|1P|1Q|C|$1R|1S]]]]

From the <a href="http://www.haskell.org/onlinereport/" rel="noreferrer">Haskell 98 Language</a> we see the core distinction in identifier tokens in Haskell:
<pre><code>varid -&gt; (small {small | large | digit | ' })&lt;reservedid&gt;
conid -&gt; large {small | large | digit | ' }
</code></pre>
That is, the language fundamentally distinguish variable names (&quot;varid&quot;) from constructor names (&quot;conid&quot;), at all levels of the language (both value and type variables and constructors). So clearly, Haskell distinguishes identifiers into two main namespaces (well, there are others, if you count modules and classes), but two primary ones, those that begin with a lower-case letter (variable identifiers) and those that begin with an upper-case letter (constructor identifiers).
So, given that we do distinguish constructors from variables, the question is &quot;why?&quot;.
Reading types
One plausible argument is that it makes it very easy to spot parameters in types (e.g. polymorphic types).
Pattern matching
Secondly, and more importantly, we have uniform syntax for data construction and deconstruction (pattern matching). Whenever you see an upper case identifier in a pattern,
<pre><code>case x of
 Foo y z -&gt; ...
</code></pre>
You know that <code>Foo</code> is a data structure being taken apart and its components named. Correspondingly, whenever you see an upper case identifier in an expression,
<pre><code>g (f (Foo 1 2)
</code></pre>
you know that <code>f</code> is receiving a newly built <code>Foo</code> data type with two arguments.
So, since constructors (both type and value) are so important in the language, this simple restriction to upper case identifiers makes it much easier for a human to see what is going on in a piece of code. In some ways upper case letters make up for the lack of other syntactic noise in the language, as an aid to the reader.
<hr />
Namespaces
<blockquote>
There are six kinds of names in Haskell : those for variables and constructors denote values; those for type variables, type constructors, and type classes refer to entities related to the type system; and module names refer to modules. There are two constraints on naming:
Names for variables and type variables are identifiers beginning with lowercase letters or underscore; the other four kinds of names are identifiers beginning with uppercase letters.
An identifier must not be used as the name of a type constructor and a class in the same scope.
These are the only constraints; for example, Int may simultaneously be the name of a module, class, and constructor within a single scope.
</blockquote>
Haskell B
In Haskell B, constructors and variables could use either case.

blocks|key|2961766|text|除了前面已经提到的消除歧义的解析等功能之外，人们阅读程序时还具有可读性(和解析)。下面是一些支持的引文：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2961767|2961768|程序必须为人们可读而编写，并且仅顺便为机器执行而编写。|blockquote|2961769|2961770|-+Abelman和Sussman，计算机程序的结构和解释|2961771|2961772|任何一个笨蛋都能写出计算机能理解的代码。优秀的程序员编写人类可以理解的代码。|2961773|2961774|2961775|-马丁·福勒|2961776|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|S|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|T|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|V|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|J|3|K|5|E|7|X|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|10|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|Q|$]]

In addition to disambiguating parsing etc., already mentioned, there's
also readability (and parsing) for humans reading the program. Some
supporting quotes:

<blockquote>
 Programs must be written for people to read, and only incidentally for machines to execute. 
</blockquote>

--- Abelman and Sussman, Structure and Interpretation of Computer Programs

<blockquote>
 Any fool can write code that a computer can understand. Good programmers write code that humans can understand.
</blockquote>

--- Martin Fowler

Give an ugly example:

<pre><code>data Bighead = Big

little = 1 

f1 = little :: Int

f2 = Big :: BigHead
</code></pre>

In my opinion:

<code>f1</code> and <code>f2</code> all point to some data. the only different of (<code>little</code> and <code>Big</code>) is
little has a piece of code to do evaluation. but Big doesn't.

They all have a rewritable body, little can be transformed from a collection of data to a result, and Big is just don't do the last step --- it always holds this data forms (but recursively they can be evaluated).

But in syntax form, they are almost the same: can be applied, can be evaluated.

One big deal may be that functions can't alter its applied params, but data can do.

Is this the only reason that Haskell treats data and function's names differently?

Call for analysis :-)

edit: some more pads

<pre><code>data A = B Int
</code></pre>

type of <code>B</code>:

<pre><code>B :: Int -&gt; A

b :: Int -&gt; A

b = B 
</code></pre>

Why does Haskell force data constructor's first letter to be upper case?

数据结构

举个丑陋的例子：data Bighead = Biglittle = 1 f1 = little :: Intf2 = Big :: BigHead在我看来：f1和f2都指向一些数据。(little和Big)唯一的不同是很少有一段代码来做评估。但Big并非如此。它们都有一个可重写的主体，几乎不能从一个数据集合转换成一个...

问为什么Haskell强制数据构造函数的第一个字母为大写？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么Haskell强制数据构造函数的第一个字母为大写？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么Haskell强制数据构造函数的第一个字母为大写？
EN