[Date Prev][Date Next][Thread Prev][Thread Next]
- Subject: Re: Soft Types System Proposal
- From: Asger Ottar Alstrup <aalstrup@...>
- Date: Tue, 26 Oct 2004 07:24:06 +0200
Thatcher Ulrich wrote:
Static typing is really effective at finding some kinds of errors.
But I have a feeling it would add too much size and complexity to Lua.
Fear, uncertainty, doubt. The proposed type system is very light weight:
The types are opaque. You can give a name to a type structure, but you
do that by example. There is no syntax to build the type structure
explicitly. So the changes to the syntax are minimal: Optional type
specifiers in a few productions, and a very simple production for the
type names themselves.
There are no changes in language semantics, so therefore there are no
changes to the bytecode generator, the bytecode itself or the runtime
API. It is possible for the compiler to use the type information to
optimise the bytecode, but that is purely optional.
The changes can be put into a separate typing pass right after parsing,
or it could even be a part of the parsing.
I believe this is a very light-weight proposal.
Also, it is the standard way of catching the class of errors we are
discussing. Yes, some subset of the problems can be caught by extending
lint, special casing globals and other such tricks like this, and that
is what we have today. These solutions are not satisfactory, because
they only handle special cases, are not portable, and are not integrated
with IDEs. When there is a problem, the programmer does not understand
what cases are caught by the checker, and which are not.
I believe there is a large class of errors which could be caught by
static type checking. This is not restricted to misspelled variables. It
is also expressions involving the wrong existing variables, which are
automatically converted to the required type and thus not discovered
If you add a light weight type system, you give the programmer better
control and a more familiar environment. You put him in control of what
needs checking and what need not, and he will feel right at home.
Compare to the upvalues in Lua: Those were a neat little trick, which
solved a large part of the problem. But programmers were not used to
just a concept, and in the end, we ended up with traditional static
typing, and I believe everybody agrees that this is much better.
The same principle applies here: Go for the standard solution from the
start, rather than some non-standard, special case solution.
Asger Ottar Alstrup