What is Expressiveness in a Computer Language

[Joachim Durchholz]

Torben Ægidius Mogensen schrieb:
> That's not really the difference between static and dynamic typing.
> Static typing means that there exist a typing at compile-time that
> guarantess against run-time type violations.  Dynamic typing means
> that such violations are detected at run-time. 

Agreed.

 > This is orthogonal to
> strong versus weak typing, which is about whether such violations are
> detected at all.  The archetypal weakly typed language is machine code
> -- you can happily load a floating point value from memory, add it to
> a string pointer and jump to the resulting value.

I'd rather call machine code "untyped".
("Strong typing" and "weak typing" don't have a universally accepted 
definition anyway, and I'm not sure that this terminology is helpful 
anyway.)

> Anyway, type inference for statically typed langauges don't make them
> any more dynamically typed.  It just moves the burden of assigning the
> types from the programmer to the compiler.  And (for HM type systems)
> the compiler doesn't "guess" at a type -- it finds the unique most
> general type from which all other legal types (within the type system)
> can be found by instantiation.

Hmm... I think this distinction doesn't cover all cases.

Assume a language that
a) defines that a program is "type-correct" iff HM inference establishes 
that there are no type errors
b) compiles a type-incorrect program anyway, with an establishes 
rigorous semantics for such programs (e.g. by throwing exceptions as 
appropriate).
The compiler might actually refuse to compile type-incorrect programs, 
depending on compiler flags and/or declarations in the code.

Typed ("strongly typed") it is, but is it statically typed or 
dynamically typed?
("Softly typed" doesn't capture it well enough - if it's declarations in 
the code, then those part of the code are statically typed.)

> You miss some of the other benefits of static typing,
> though, such as a richer type system -- soft typing often lacks
> features like polymorphism (it will find a set of monomorphic
> instances rather than the most general type) and type classes.

That's not a property of soft typing per se, it's a consequence of 
tacking on type inference on a dynamically-typed language that wasn't 
designed for allowing strong type guarantees.

Regards,
Jo