separate compilation, interfaces, ...

bind takes two arguments and returns two arguments (so all args can be passed to the bind funtion):
        _bind(selector, receiver, arg1, arg2, ...)
    =>
        <entry-point>(method, receiver, arg1, arg2, ...)
    (where method might or might not be [derived from] the original selector)

Floats (Doubles?).

init temps to nil, or warn of use before define.

primitive types

C99 scanner, preprocessor, parser; parse -> internalise type info

fix temp name problems:

	[ | foo | ..... ]   " <---- open-coded block "
        foo ...             " <---- still in scope "

    -> push then pop new environment, without increasing nesting level (or pop them off the end of the env when scope exits)

mangle member names ('default' is not a valid member name)

{ include <stdio.h> } and similar...

{ import foo bar baz }
{ include <time.h> <sys/time.h> }

compilation to .so

shared literals (1 instance of each value)

----------------------------------------------------------------

(define (class Object) nil ())

(define (send Object integer: anInteger)
  (stdio.printf "Object.integer: %s!\n" (integer-value anInteger))
  self)

(send Object integer: (integer-object 42))

----------------------------------------------------------------

With the right annotations 'real' Smalltalk (or something you can't
tell apart given a Smalltalky parser) can be as expressive as C (and
quite a way beyond that, in terms of dynamism).  No more Slang.  No
more platform support written in C.  In fact, no more VM at all.  What
used to be the VM is now just a 'kernel' within a single, homogeneous
continuum that stretches from user applications all the way down to
the metal -- with a few annotations thrown in at the metal end to help
the compiler generate the right instructions.  (Essentially, just type
annotations: C scalar type annotations eliminate the need for most
primitives, then structure/pointer types [and the ability to parse C
header files to extract type information transparently] takes care of
the rest.  Add a small taxonomy with a message-based theory of
implicit coercion between objects and primitive types, and the end
user need never see even a single type annotation.  The right object
model also allows C structures, completely interoperable with the OS
and platform libraries, simultaneously to be full objects --
responding directly to intrinsic, late-bound message sends.)

Next give selectors the power to intercede in their own compilation
(kind of like Forth's compiles>does> or Lisp's [klunky] syntax table
thing) and you have something that's more powerful than Lisp (let
alone CPP) macros -- to the extent that you can transform message
receiver single dispatch into genuine multimethod dispatch, without
ever leaving the end-user programming model.