Hi,
I'm familiar with the capitalization rules for identifiers in Haskell
and know that they are very useful and practical e.g. by allowing
variables to be distinguished from "constants" in patterns etc.
However I'm trying to understand on a much deeper level whether or not
they can really be justified and indeed if there is a danger that they
can lead to inconsistency in the light of future extensions to the language.
For example, why is there any distinction between a type "variable" and
a type "constant"?
To make this clearer consider the type of (map):
(a -> b) -> List a -> List b
(ignoring the special [] syntax for list types which would just confuse
the issue here).
With explicit quantifiers, we'd write:
forall a b. (a -> b) -> List a -> List b
Now this begs the question: why does "List" need to start with a
capital? (supposing that quantifiers were always written explicitly)
The same distinction between "constants" and "variables" is also used in
predicate logic e.g.
On(x, Table) & Colour(x, Red)
but similarly the above could surely be written just as easily by:
exists x. on(x, table) & colour(x, red)
where (on), (table), (colour), and (red) are just considered to be
variables that have already been introduced (by some enclosing scope)
instead of having to think of them as "constants" and make a distinction
between "constant" and "variable".
Anyway to get to the point of this post what I'm really trying to find
is some explanation of why there is the concept of "constant" as opposed
to "variable" or whether this concept is now redundant in the light of
lexical scoping/ explicit quantification?
Somewhat related to this issue is the syntax of associated type
families. For example in section 5.2.2 of
http://www.haskell.org/haskellwiki/GHC/Indexed_types there is the example:
class C a b where
data T a
which raises in my mind several questions:
1) Why is (T) given a parameter? I.e. why does an associated type
declared inside a class decl not automatically get all the parameters of
the class passed to it so that one would just write:
class C a b where
data T
f :: T -> T
===
data family T a b
class C a b where ...
f :: T a b -> T a b
2) Compare:
class C a b t | a b -> t
with
class C a b where
data T
In other words, why is (T) a "constant" when it is declared inside the
class but a "variable" when passed as a parameter?
Is the fact that (T) needs to be given a parameter even when it is
declared inside the "scope" of the class type parameters the result of
needing to fulfill the idea of "constant" vs "variable"?
3) In the syntax:
class C a b
data T a
it seems rather odd that the "a" in "T a" should be related to the "a"
in "C a b" since one might expect that the name chosen for a parameter
should be local to the data decl.
Apologies for such a rambling post. I've spent literally at least 6
months scouring the internet trying to find a real discussion about
capitalization rules because I'm trying to answer the following
question: if I make use of a similar capitalization rule in my own
language, can I guarantee that this rule will not lead to an
inconsistency at some future point? Ie is there a real rock solid
theoretical basis for making a distinction between "constants" and
"variables" that holds even in the presence of lexical scoping?
Thanks, Brian.
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
