Re: Declaration design preference: type or name first

James Harris <james.harris.1@[EMAIL PROTECTED]
> writes:

> Would you go so far as to not even indicate which identifiers are
> integers, floats or strings? Or, by type inference, do you tell the
> compiler a certain object is an integer but without telling it how
> wide that integer must be leaving its width to be inferred?

As Robbert said, the normal procedure is to derive the type of a
variable from the operations performed on the variable.  This is fine
as long as operators are not overloaded.  OCaml uses differently named
addition operators for integers and floating point, so it can uniquely
find the type from the operations.  Standard ML overloads + for both
integers and reals, but it does not allow the overloading to be
unresolved, so unless there are other operators that narrow the type
to either int or real, the compiler defaults to integer.  This can be
overriden by adding an explicit type annotation.

Haskell uses type cl***** to handle overloading.  Here, + is an
operator in the Num type class, and you can specify any type to be an
instance of the Num class by specifying the required operators (+, -,
* and so on).  If you write a function

f x = x+7

the inferred type is

f :: Num t => t -> t

which says that f is a function that takes a value from any type t
that is an instance of the Num type class and returns a value of the
same type.  This would make it illegal to apply f to, say, a string,
as the string type is not an instance of Num.  Note that the constant
7 is overloaded too: The compiler implicitly inserts an operator
"fromInteger" around each integer constant, and the Num type class
requires you to specify fromInteger.  So, if you apply f to double,
the integer 7 would be converted to a double before adding it to the
argument of f.  So, writing "f 4.3" would return 11.3.

Haskell has a large number of predefined numeric types including
bounded and unbounded integers, fractions, doubles and complex
numbers.

	Torben