Here’s the deal, in tinypyC++, when compiling I actually do check for None vs int and throw a compilation error at that point. So your code “can’t” assign None to an int.

However if you read my post earlier this week about Exceptions, I’ve since added an optional exception-free mode to tinypyC++. So in cases like this [1,2,3].pop(5) it will print an error to stderr and return “None”. But I had to decide if “None” was more like 0 or -1. To be clear, this will never happen when exceptions are enabled (which is the default behavior.) Exception-free mode is enabled by -DTP_NO_THROW.

In tinypyC++ you can assign an object = None and it will nullify the internal pointer and reduce the ref-count.

That said, this looks like an exceptional case to me. You have a choice between failing loudly, or doing the wrong thing sometimes. If tinypyC++ will frequently be used on third-party code, then perhaps zero is best; otherwise, error out.

tinypyc++ ints should definitely be ints in C++, so int* or the tuple idea above are out for performance reasons.

So for use cases, here’s ones I can think of:

x = None
if something_condition:
x = something_other_than_none
if x:
do_something()

x = something_other_than_none
if some_condition:
x = None
if not x:
do_something()

x = something_other_than_none
if some_condition:
y = None
else:
y = some_other_number
if x == y:
do_something()

I know you’re big on unit testing, so I would definitely think that there should be a fair number of x = None : int unit tests to build, and that they should all look reasonable.

I’m still leaning towards 0 though.

OTOH – what about 0×80000000..
(for a 32bit machine, this is the one negative number which doesn’t have a positive counterpart)
I think this is same what Mike also suggested as one possibility.

But why are you considering allowing “int” variables to be set to “None” in the first place? Why bother to have typed variables unless you’re going to enforce type safety? Whatever those circumstances are where you wanted to say “int x = None”, you should change *that*.

If that’s not an issue, I’d make it a symbolic constant, i.e.
#define NONE_VAL (0xDEADBEEF)

That way it’s easy to spot in a debugger.

I am guessing this occurs because tinypyC++ needs to declare “x” before it is assigned a value.

Perhaps you can define a particular int (e.g. -sys.maxint-1) to mean None, analogous to NaN for floating point.

Alternatively, values can be represented internally by a 2-tuple (valid,value).

int x = None; would become “Int x = (False, dont_care);”.
int x = 42; would become “Int x = (True,42);”

define appropriate casts to convert back and forth between “Int’s” and “int’s”.

void main()
{
unsigned int a = (unsigned int)-1;
unsigned int b = 0xFFFFFFFF;
if (a == b)
{
printf(“Same thing!\n”);
}
}

>> a.out
Same Thing!
>>