Here is one major request I would like to ask for: Data Structures.

I'm talking about structs somewhat like that which can be seen in C, but possibly simpler, where the size of each element within is somewhat constant to only 8 bit or 16 bit ints with possibility of random data to be included as well, such as pre-terminated Strings.

Here is my idea -- struct declaration would be similar to an ALGOL-based block.  Each element inside doesn't have a name, but simply a number, and the expression on each line, depending on it's form, will be added as an element to the struct.  To specify size before the value, simply one would put th size as a number the line before, and just add a colon for prettiness:

StructDef Kitty
  1:15 .add element 0 to be 8 bit char with value of $0F
  2:6000 .el. 1 is a 16 bit int with value of 6000
  8:"Hellolol" .el 2 is pointer to a string with an actual value
End
Or even easier, just allow for size to be determined at declaration, and all values upon struct declaration are undefined:

StructDef Kitty
  1
  2
  8
End
(I actually would rather the second option)

Creation would be simple, in fact, really simple.  You could use any 16 bit pointer as a pointer to a struct, and simply just do something like:

Disp Struct(A,Kitty,2) .disp string stored in element two of structure A
With this in mind, all pointers would have to actually allocate space and fill the space with data by their own means, but the pointer would be treated in accordance with the design of the access struct, Kitty.

This method would be the easiest way to implement this sort of struct data type, and would be very useful to many people, even if it is just syntactic sugar for manual indirection.

If you choose not to implement it into the language standard, I understand, I can find a way to make it in Axiom form

Here's a table/list of them: http://tibasicdev.wikidot.com/83lgfont

Edit: Ninja'd.  Twice. 

Really well done on the new version!  I haven't upgraded yet, but I'm pretty sure you can't nest includes, which would be a nice feature.

Can we get 32-bit math, please?

In addition to structs, another nice feature would be expression continuation over multiple lines.  Take this for example:

Code: [Select]

lambda(Pt-on(r1,r2,r3):Pt-on(r1,r2+8,r3+8)) -> A
It would be nice if when a line ends with a colon, the expression isn't closed at the end of the line, but rather continued on the next one:

Code: [Select]

lambda(Pt-on(r1,r2,r3):
Pt-on(r1,r2+8,r3+8)) ->A
I'm finding myself writing long lambdas ATM for TaN (don't yell at me for making it Axe based again, I only did it because the new functional features make life so much easier considering enemies), some of which take dozens of lines.  This addition would be very helpful

You could just write the function as a subroutine and then deference the pointer to the subroutine.

By the way, I should mention that lambda currently produce 3 extra bytes of code compared to using regular label names.  Label names are also neater and allow more flexibility with code.  Lambdas are meant to be used as expressions, that is, they take in arguments and return a value.  This could maybe optimize better in the future.  Also, using variables as single byte values is less optimized than if you had just used the 2 byte form, at least until I can optimize in some 8-bit math.

If the subprograms are in RAM, you can press PRGM to open the faulty program and it'll scroll to the line the error occured at.
However, if you keep programs in the Archive (like I do), it'll just exit when you press PRGM, so it would indeed be nice if it displayed in which subprogram the error occured.

By the way, I should mention that lambda currently produce 3 extra bytes of code compared to using regular label names.  Label names are also neater and allow more flexibility with code.  Lambdas are meant to be used as expressions, that is, they take in arguments and return a value.  This could maybe optimize better in the future.  Also, using variables as single byte values is less optimized than if you had just used the 2 byte form, at least until I can optimize in some 8-bit math.

So, I guess that's a no to the continuation of lines thing?  Even if I just did use them as expressions, expressions can get pretty damn long.  That's why I asked for it.