Hidden integers...

Hi there,

Been using lua a while in a couple of projects, and I haven't really found anything I'd like to add to this elegant and simple language... anything except perhaps integer support.

Proposal:

My proposal would be to implement integers as the default internal format of 'numbers' assigned by integer constants or exclusively integer expressions. Integers would look and act just like the number type, and would only be distinguishable in two ways...

1. They would return the string "integer" from the type() funciton.

2. They would print in integer format and not floating point format with the "print" function.

In all other ways, they would work identically, and be indistinguishable from numbers.

Rationale:

1. As a scripting language, lua must interface with C code which is largely integer based, and contains numerous instances of bit flagged variables, shifting, and integer arithmatic. Representing these values, and performing these operations in lua presently is either poorly handled or not possible.

2. Representation of floating point values as doubles is required because lua does not support true integers. In game applications where floats are the primary floating point value used, constant conversion of floats to doubles and floats to integers take place.

3. Certain operations which return imprecise results in floating point (division, multiplication, etc.) are better handled using integer arithmetic.

4. In many cases, integer arithmetic in the VM is faster than floating point arithmetic.

5. Integer supported added in the way proposed would not break existing programs (except those which may depend on all numeric variables returning the string "number" for the function type()).

Details:

Integer constants would be represented in lua as integers and not floating point values. Assignment of an integer value to a variable would result in an integer variable.

i.e.

i = 100

Would be stored internally as an integer.. while

i = 100.0

Would be stored internally as a float value.

Addition and subtraction of two integers would return an integer result..

i.e.

i = 100 - 50

would result in an integer 50.

The multiplication of two integers would result in an integer unless the number overflowed, in which case it would be a number. The overflow would be dictated by the size of the integer, which would default in compiler flags to 64 bit, just as float values default presently to 'double' floats.

i = 100 * 100

would result in integer 10000

while

i = 10 * 2000000000000000000000 (not sure where 64 bits would overflow)

would result in the floating point value

20000000000000000000000.0

Any _expression_ mixing integers and numbers would result in a number.

i.e.

i = 100 - 50.0

i = 100.0 - 50

i = 10 * 5.0

i = 100 / 2.0

would result in a number 50.0

The following methods would support integer operations.

i = tointeger(n)

Would convert a string or a number to an integer.

d,r = idiv(a,b)

Would return the result of an integer division, returning its integer result and the remainder.

i = imult(a,b)

Would return the integer result of multiplying integer values a,b and would not convert to a number on overflow. If a and b were not integers, they would be converted to integers.

i = ishift(i, bits[, precision])

Would return the bits of integer i shifted by d. The optional precision value would be 8 for 8 bit precision, 16 for 16 bit, 32 for 32 bits, and 64 for 64 bits.

i = iand(a,b)

Performs an integer bitwise AND operation on two values.

i = ior(a,b)

Performs a bitwise integer OR operation on two values.

i = inot(i)

Performs a bitwise integer NOT operation on two values.

i = ixor(i)

Peforms a bitwise integer XOR operation on two values.

The function

type(i)

would return "integer" if the value passed was an integer.