Re: Declaration design preference: type or name first

On 13 Nov, 08:43, Robbert Haarman <comp.lang.m...@[EMAIL PROTECTED]
>
wrote:
....
> > I see your point. Lets say that if I read someone else's code I want
> > to be able to see how polymorphic his functions are!
>
> I see your point, but I feel it is getting the territory of "everybody
> should do things the way I want them cause I think that's better for
> me!". Type inference saves you work while developing and refactoring
> code. This benefits everybody working on the project, including you.

Haha. A bit of control-freakery never hurt anyone! In reality that's
not the intention. All high-level languages provide some /
restrictions/ on what can be done. Some, admittedly, are incidental.
Others, though, are included simply because they constrain the
programmer. Hate that restraint? I guess we would if it really hurt.
On the other hand for any programmer to look at a piece of compilable
code being able to rely on certain assumptions makes the programmer's
life easier. Examples: data hiding, structured programs without gotos,
local identifier names. These make our lives easier both if we have to
edit someone else's code and even if we have to go back and edit our
own code a few months or so after writing it. We like restrictions /
if/ they are well chosen. I was merely pointing out the benefits of
do***enting types rather than leaving them to be inferred.

> I would like to add that type annotations have real value, and, in fact,
> it is considered good practice to add them by the Haskell and OCaml
> communities, even though these language do not mandate them. What I
> typically do is write my code without type annotations first (saving
> effort while adding and refactoring code), and then, when the time comes
> for type annotations (for example, because I want to share the code with
> someone else, or I am not sure about the inferred types myself), I have
> the compiler generate the type annotations for me. This lets me focus on
> the algorithms and the structure of the code, rather than annotations,
> while still providing the latter.

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?