The problem is that hard-wiring things like const, or non-null pointers, or regions (ala Cyclone), introduce significant complexity into a language design. These are powerful abstractions, but because they are hard-wired they are inelegant and contribute to overall language complexity and its inability to adapt to new paradigms.

A clue to a possible solution occured to me recently when examining Cyclone. A memory-safe dialect of C. It uses the type-system (at compile-time and run-time) primarily to assure that the program is type-safe.

What occured to me, was that the Cyclone group developed a more sophisticated static type system. What I want to see is this kind of system generalized so that a C dialect can have an easily extended type-system. (I have this nagging feeling that I am just reinventing OCaml in small steps, but at least I am approaching it as a software developer and not an academic simply interested in lambda calculus and type-safety proofs).

At this point is where my flight-of-fancy begins. I believe that a language where all variables (including the "this" pointer) can have their type redeclared, would be sufficient to cover many abstractions such as "const" or "is-initialized". Consider the following pseudo-code:

class Initialized<type T> {
  subtypes {
    T;
  }
}

class Const<type T> {
  subtypes {
    T;
  }
}

class FuBar {
  public 
  {
    def Init() { 
      assert(!is_initialized(this)) 
      reassign_type<Initialized<FuBar>>(this);  
    } 
    def Fu() { 
      assert(is_initialized(this)) 
    } 
    def Bar() { 
      assert(is_const(this)) 
      assert(is_initialized(this)) 
    } 
  }
}

FuBar a;
a.Fu(); // boom, not initialized
FuBar b;
b.Init(); 
b.Fu();
b.Bar(); // boom, not const
Const<FuBar> c;
c.Init();
c.Fu();
c.Bar(); 

class FuBar {
  public 
  {
    def Init() { 
      assert(!is_initialized(this)) 
      reassign_type<Initialized<FuBar>>(this);  
    } 
    def Fu() { 
      assert(is_initialized(this)) 
    } 
    def Bar() { 
      assert(is_const(this)) 
      assert(is_initialized(this)) 
    } 
  }
}

class FuBar {
public:
  FuBar(...) {
    // ...
  }

  void Fu() { 
    // ...
  } 
  void Bar() const { 
    // ...
  } 
}

public 
{
  def<Initialization> Init() { 
  } 
  def Fu() { 
  } 
  def<Const> Bar() { 
  } 
}

  my_class a;
  a.f();
  a.g();
  a.h();

  my_class a;
  my_class::f()(&a);
  my_class::g()(&a);
  my_class::h()(&a);

  my_class<my_class> a;
  my_class<my_class>::f()(&a);
  my_class<my_class>::g()(&a);
  my_class<my_class>::h()(&a);

  my_class<my_class> a;
  typedef my_class<my_class> T0;
  T0::f()(&a);
  typedef my_class<T0::f::transition<T0>::new_type> T1;
  T1::g()(&a);
  typedef my_class<T1::g::transition<T1>::new_type> T2;
  T2::h()(&a);  

class ImmutableInteger implements Imutable {
  private final int value;
  ImmutableInteger( final int value ) { this.value = value; }
  ImmutableInteger plus( final ImmutableInteger rhs ) { new ImmutableInteger( value + rhs.value ); }
}