@El Foo said:
I assume that it means C# is more laden with type
messages than other strongly typed languages. For example, converting
foo to bar, where bar needs type a:
b bar = (b) foo
compared to the pure functional language of your choice:
bar = b foo
These
redundant type messages carry weight, and the longer a program is, the
more needless mass there is, so C# is 'heavily' typed, compared to
'lightly' typed languages (Haskell, OCaml, etc), or 'featherweight'
typed languages (scripting languages - no type declarations at all!).
No, that isn't it. That requirement for explicit conversion is a sign
of "strong" typing. Pay close attention: C++ is weakly typed. It's
just also very statically typed. Python offers strong, dynamic typing,
for comparison. Many people falsely associate weak typing with dynamic
and strong with static, but they are actually pretty much orthogonal.
I do think "heavy typing" makes sense as a term; I think of it as
referring to the complexity of the type system and the kinds of options
you have for expressing types. So for example C++ has very "heavy"
typing, because there are both user-defined types and parametric
polymorphism (templates) on both integer values and other types;
whereas Perl 4 (pre-OO stuff and references) is about as "light" as
typing can get, since there are really only three types - scalar, array
and hash. (Whether you consider it static or dynamic, or weak or
strong, is actually not very clear. If you're strict about the
interpretation of those as the only types, then it's static for
example; but it's dynamic if you consider automatic interpretation of a
string that "happens" to represent a number, as a number, to be a "type
conversion".)