Compile-time constants in languages, have a special status. In C++ under some conditions, an expression involing compile-time constants is resolved at compile-time. When and if this occurs is often implementation defined, and is unreliable. What I want as a programmer is explicit control over when and how compile-time evaluations occur. Macros/Template Meta-Programming provide very clunky methods of computing compile-time expressions.

What this implies is that in the statement: int x = 3 + 5;, the value 3 and 5 do not really behave like variables of type int, but rather something different. One big difference is they occupy zero bytes. Ironically if I took the size, e.g. sizeof(3), I would get a non-zero value, but in reality, no storage is allocated. This is why I consider constant integer literals as instances of a separate type, which I call a meta-int. In Heron I plan on identifying a meta-int as #int. A meta-int would support both implicit converion to its corresponing run-time type, as well as possibly explicit conversion though the $ operator.

Anyway on to the problem of mapping a Heron statement to a macro call. Consider the statement:

  if (some_bool_expression) then { do_something; } else { do_something_else; };

The syntax which is currently my leading favourite is:

  class if { }
  class then { }
  class else { }

  macro (#type x0==if, ...) =
    ERROR "invalid if statement";

  macro (#type x0==if, bool condition, #type ignore0==then, #code on_true) =
    COND condition on_true;

  macro (#type x0==if, bool condition, #type ignore0==then, #code on_true, #type ignore1==else, #code on_false) =
    COND condition on_true true on_false;

Now this is purely hypothetical, and it would be some time before I could implement all of this in the Heron prototypes. I am worrying about the syntax, because it makes it easier to imagine using the language in a thought experiment and can affect other design decisions (e.g. significance of ";") as well as the implementation.

class then {
  #code do;
  void then(#code do) {
    *.do = do;
  }
};

class else {
  #code do;
  void else(#code do) {
    *.do = do;
  }
};

class if {
  void if(#statement cond, then if_true, else if_false) {
    COND cond if_true.do true if_false.do;
  }
};

x = sin(3.1415926);

x = 0

x = 3;

class then {
  public
  {
    typedef do : #code; // do is a type, not a field.

    _init() {
      then(#code do) {
        this:do = do; // unfortunately illegal, you can't assign a type.
      }
    }
  }
}

type_alias then[code do_T] = do_T;

type_alias else[code do_T] = do_T;

type_alias if[code condition, type if_true, type if_false] = 
  COND[condition, if_true, true, if_false];

template<code do_T>
struct then {
  typedef do_T do;
};

template<code do_T>
struct else {
  typedef do_T do;
};

template<code condition, typename if_true, typename if_false>
struct if : COND<condition, if_true::do, true, if_false::do>
{ };

> x = sin(3.1415926);
> 

  template<int N>
  void fubar() { };  
  fubar<3>(); 
  int x;
  cin >> x;
  fubar<x>(); // doesn't compile

template<int N>
  void fubar() { };  
  fubar<3>(); 
  int x;
  cin >> x;
  fubar<x>(); // doesn't compile

template<int N>
void fubar() {};
fubar<3>();
const int x = 4;
fubar<x>();

mov eax,8

mov eax,3
add eax,5