🚀 go-pugleaf

I would like to thank Doug Moen and others for their precise definitions.
My example wasn't very good, so a number of people still don't see why
dynamic scoping is incompatible with static type checking.  I'll try
again here with the help of the following example:

In article <588@watcgl.UUCP> kdmoen@watcgl.UUCP (Doug Moen) writes:
>In the (fortunately nonexistent) language "dynamically scoped Ada",
>[Will's] example would be written as:
>
>	FOO: function (N: INTEGER) return INTEGER is
>		import X: INTEGER;
>	begin
>		return X + N;
>	end FOO;
>
>In general, every variable mentioned in the body of a function in DSAda
>must be a formal parameter, a local variable, or an imported variable,
>which is inherited from the calling environment.

Type declarations aren't enough to support static type checking when the
language is dynamically scoped.  Yes, the compiler can check that all uses
of X within FOO are consistent with the "import" declaration.  That's easy.
The problem is that the compiler cannot check statically to make sure that
FOO will be called only when X is an integer variable in the dynamic
calling environment.  That is, the compiler cannot tell whether it should
believe the declaration.  Indeed, it is statically undecidable whether X
will denote anything at all when FOO is called.

This is the reason that dynamic scoping is incompatible with static type
checking.

That's not to say that dynamic scoping is incompatible with type
declarations.  Type declarations can improve performance even though
static type checking is impossible.

Peace, Will Clinger
Tektronix Computer Research Lab