Expand numeric type family

[KnightBreaker]

Introduce all remaining int types such as (u)int8 etc.

Together with bit operations this would be great for optimizations and bit masking. Using a big int for every integer value seems like an overkill.

[KnightBreaker]

@sprintermax you can post your example here.

[sprintermax]

Verse already has reserved names for types such as int8, int16 and so on. But currently does not implement them.

We can make refinement types and/or type aliases in verse, but it has lots of limitations when comparing to other languages:

• Can't use the reserved type names, we are forced to name them things like _int8 for example
• Can't override/replace operations or functions related to the type with more specific and/or precise implementations,
• Lots of conflictings due to type hierarchy that we can't deal with, on many times, specially due the reason above, it converts out/back to the supertype without ability to control/disable or limit that behavior

And so on...

---

For example, calling any operation such as "Add" with two custom-made int8 is not failable (out of range), and returns normal int back. This makes absurdly annoying to work it, needing to cast back to the correct types and so on every time needed. I've tried other alternatives such as creating dummy classes/structs and storing the values inside, but it also has lots of other downsides, just adding more friction...

I have a string related module and I use this a lot on my libraries to constrain and do operations (ex. utf8 character as int8, rune for bigger character ranges and so on), for string manipulation, hashing, binary operations and so on... (verse lacks a native string processing library and we need to do everything from scratch - which is a problem for another discussion)

Besides this strings example, there is always the memory topic, when we explicitly want to constrain the memory allocated for that type (for implementation or just efficiency purposes too)

I've attached some images related to some of my usages (13MB+ of verse files just for data about unicode implementations for string processing). It is just one example but from time to time I face other roadblocks due to "oh, sadly verse does not support / does not allow that"...

This, combining with many other restrictions, including #27, #43 and so on, makes working on libraries and some usages having more friction than it should...

[sprintermax]

Some more examples - Check how me "attaching" a function to a constrainment type also applies it to the base type too (which is weird - it should not allow that and can cause bugs and limitations when making libraries):
(Note: I wrote this before knowing that Constrained Types is the correct term)

I believe all this will be possible with function-as-types tho... But we probably will be able to "inject" dummy signatures to force being different and avoid conflicts due to the many shadowing or qualification limitations

[sprintermax]

Some primitive types that may be worth mentioning and how I imagine them if existing in verse:

# supertype := subtypes included

uint := (uint8 | unit16 | uint32 | uint64)
int := (int8 | int16 | int32 | int64 | uint | <arbitrary_precision_integer>)
rational := (int | <fraction>) # Has Dividend and Divisor parts
float := (float32 | float64 | decimal | <arbitrary_precision_float>)
complex := (complex64 | complex128) # Has real and Imaginary Parts
number := (float | complex | rational) # "umbrella" type for all numeric types

char := (char8 | char16 | char32)

# example aliases for easier usages:
string := []char
byte := uint8
rune := int32 # similar from GoLang

Also more API Libraries for already existing stuff (ex. rationals are absurdly limited, floats lack customization of rounding behavior and so on...)