On Thu, 2006-08-31 at 15:36 +0900, Jacques Garrigue wrote:
> From: skaller <skaller@users.sourceforge.net>
 
> > Try to tell someone in the C++ community that C++ is severely 
> > constrained because it doesn't have first class lexically
> > scoped functions, variants, or pattern matching .. even
> > if you explain what they are they'll just say "Oh, we can
> > do that this way .. but don't have much call for it".
> 
> Here you have to read between lines :-)

Spying between the cracks between the boards whilst ROFL?

> I am a user of the debugger, and I also use objects at times, so I
> have a personal interest in having better support for objects in the
> debugger, through RTTI for instance. But this would be quite a bit of
> work, 

.. especially in the native code system ..

> so this is difficult to justify if I'm the only user. Hence the
> above wording...

> If you think of it, debugging contains all the difficulties of RTTI,
> but without the justification for _not_ having it, that is, you clearly
> want to break abstraction when debugging. 

Good point.

> So that to do things
> properly, we would even want to now dynamic type information about
> polymorphic types, which is even harder than for objects.

It is my guess (and only a guess!) that there is a balance
between run time checks and compile time checks.

Typing is always an abbreviation (abstraction) and sometimes
stronger or weaker than desired: for example array bounds
checks at run time, because the type system doesn't cope
with array sizes as part of the type.

All compilers do this. Some delegate a lot more
to run time than others eg Java: I pick Java because
contrary to popular opinion it is basically a dynamically
typed language, with a bit of static typing thrown in
for a few scalar types :)

C++ tends to err the other way: it is basically
statically typed, with exceptions and casts using RTTI.

Plus of course in *all* cases programmers spend a lot
of time implementing their own application specific kind
of run time typing .. because in some sense that is what
a program does: there is no clear boundary between
the concept of 'type' and 'data'.

The real issue here is surely how to do dynamic typing
systematically and coherently *within* the confines
of static typing regime.

The most interesting recent example I've seen of this
is in Alain's XDuce stuff, where 'regular expression'
actually becomes a type not a data structure.

In this case, programmer want so often to play with
XML and keep repeating the same run time coding patterns,
it is worthwhile enriching their environment with a typing
regime based on those patterns. This is a very beautiful
piece of work!

-- 
John Skaller <skaller at users dot sf dot net>
Felix, successor to C++: http://felix.sf.net