(IDEA) Ranged Type System

[TheNachoBIT]

This is an idea that i had for a while, heavily inspired by Ada.

I'm not putting this as a proposal, because (imo) it doesn't solve current problems, and its not the end of the world if Carbon doesn't add this, but it could've be cool for both safety, organization and future-proofing for other architechtures.

There's still a ton of edge-cases that could've be added, so feel free to give a comment/opinion on this :D

Intro

Range Types are types that represent a set of all numbers within a specific range.

Integer Range (irange).

irange <identifier> = <lower_bound>..<upper_bound>;

// 0 is implicitly added as the lower bound.
irange <identifier> = <upper_bound>;

irange RoomTemperatureC = 20..50;
irange ShoppingListId = 20;

Floating-Point Range (frange).

frange <identifier> = <lower_bound>..<upper_bound>;

// 0 is implicitly added as the lower bound.
frange <identifier> = <upper_bound>;

frange Sanity = -100.0..100.0;
frange SpeedLimitKMPerHour = 0.0..200.0;

Enums.

Thanks to this system, enums can also have an internal lower and upper bound.

enum Toggle {
  Off = 0, // Lower Bound
  NotSure,
  On, // Upper Bound
};

Aliases

A range type can also be derived from an existing range type:

irange <identifier> = <existing_type>;
frange <identifier> = <existing_type>;

irange Limit = 1000;
irange EntityId = Limit;

However, by default they can't be implicitly casted.

let enemy_id: Limit = 1;
let entity_id: EntityId = 2;

enemy_id = entity_id; // ERROR: Expected "EntityId" type, found "Limit".
enemy_id = entity_id as Limit; // OK.

Architechture Ranges

The only exception of integer ranges that can be implicitly casted, are "Architechture Ranges". Ranges that hit the highest possible range the target you're compiling to can contain.

There's two types of arch ranges:

• ARCH_UINT: Highest Unsigned Architechture Range.

irange unsigned_max_one = ARCH_UINT;
irange unsigned_max_two = ARCH_UINT;

let example_one: unsigned_max_one = 10;
let example_two: unsigned_max_two = 10;

example_one += example_two; // OK (20)

• ARCH_INT: Highest Signed Architechture Range.

irange unsigned_max_one = ARCH_INT;
irange unsigned_max_two = ARCH_INT;

let example_one: unsigned_max_one = 0;
let example_two: unsigned_max_two = 10;

example_one -= example_two; // OK (-10)

However, you can't implicitly cast an ARCH_UINT to an ARCH_INT, and viceversa:

irange umax = ARCH_UINT;
irange imax = ARCH_INT;

let example_one: umax = 10;
let example_two: imax = 10;

example_one += example_two; // ERROR: Expected an Unsigned Architechture Range (like "umax"), found ("imax").

Implicit Ranges

These are ranges that can be implicitly casted, as long as they fit into the range:

irange Limit = IMPLICIT(0..10);
irange HigherLimit = 0..100;

let a: Limit = 5;
let b: HigherLimit = 1;

a += b; // OK.
a += b as Limit // OK, you can explicitly cast aswell, but its unnecessary.

a = 10;
b = 50;

a += b; // ERROR (Out of bounds...).

b += a; // ERROR: Expected "HigherLimit", found "Limit" (you can't cast viceversa).
b += a as HigherLimit; // OK.

Compile-Time Checking.

Because we're already setting lower and upper bounds, it can be used to check at compile-time.

irange FootballMatches = 5..10;

fn SetChampionshipMatchAmount(amount: FootballMatches) {
  // ...
}

fn Main() {
  SetChampionshipMatchAmount(4); // ERROR: "FootballMatches" can't be lower than 5.
  SetChampionshipMatchAmount(11); // ERROR: "FootballMatches" can't be higher than 10.
  SetChampionshipMatchAmount(10); // OK
}

Same happens with enums.

enum MysteriousBoolean {
  Off,
  MaybeOff,
  Neutral,
  MaybeOn,
  On,
};

// ...

let real_boolean = false;
let mysterious_boolean = MaybeOn;

real_boolean = mysterious_boolean as bool; // ERROR: "mysterious_boolean" is set to "MaybeOn" (3). A "bool" type expects range from "false" (0) to "true" (1).

Run-Time Checking

One of the cons of this system is that, in the worst case scenario, the compiler needs to add checks at runtime:

// Using the FootballMatches example

let match_limit: FootballMatches = ...;

// Insert scenario here where the code can't be
// statically checked...

// Implicit Check for Safety Here...
// if (match_limit < 5 || match_limit > 10) {
//    Panic!
// }
SetChampionshipMatchAmount(match_limit);

Standard Library Use.

This system can be used in the standard library to set the basic types: i32, u32, etc.
It brings the possibility for future-proofing for new architechture types, and it allows the language to have no hardcoded primitives, giving more flexibility.

// Signed Integers.
irange isize = ARCH_INT;

irange i8 = -(2 ** 7)..+(2 ** 7 - 1);
irange i16 = -(2 ** 15)..+(2 ** 15 - 1);
irange i32 = -(2 ** 31)..+(2 ** 31 - 1);
irange i64 = -(2 ** 63)..+(2 ** 63 - 1);

// Unsigned Integers.
irange usize = ARCH_UINT;

irange u8 = 2 ** 8 - 1;
irange u16 = 2 ** 16 - 1;
irange u32 = 2 ** 32 - 1;
irange u64 = 2 ** 64 - 1;

// Common Integers (C Compatibility).
irange int = /* A C signed integer. */;
irange uint = /* A C unsigned integer. */;
irange long = /* A C signed long. */;
irange ulong = /* A C unsigned long. */;

irange char = /* A C character. */;

// A C Signed and Unsigned Short, according to the C Standard.
irange short = i16;
irange ushort = u16;

// Floating Point Types.
// - Best possible range of a single precision floating point number, according to the IEEE 754 Standard.
frange f32 = -((2 - (2 ** -23)) * (2 ** 127)).0..+((2 - (2 ** -23)) * (2 ** 127)).0;
// - Best possible range of a double precision floating point number, according to the IEEE 754 Standard.
frange f64 = -((2 - 2 ** -52) * (2 ** 1023)).0..+((2 - 2 ** -52) * (2 ** 1023)).0;

frange float = f32;
frange double = f64;

// Boolean
enum bool {
    false,
    true,
};

Arrays.

Because ranged types are numbers internally, they can be used in arrays. Arrays will store a range, instead of an integer as a limit:

Newtype Indices:

irange FruitId = 30;
irange VegetableId = 20;

let fruits: array(Fruit, FruitId) = ...;
let vegetables: array(Vegetable, VegetableId) = ...;

For limits:

irange StorageLimit = 150;

let storage: array(Storage, StorageLimit);
let access_item: int = 160;

storage[access_item as StorageLimit] = Storage { ... }; // ERROR: (Out of Bounds...)

And even use it in bufs (dynamic arrays):

irange EntityId = u32;

let entities: buf(Entity, EntityId) = ...;
let other_buf = buf(AnotherClass); // Implicitly added an unsigned architechture range.

let entity_id: u32 = 10;

entities[entity_id].SayHello(); // ERROR: Expected "EntityId", found "u32".
other_buf[entity_id].AskQuestion(); // ERROR: Expected an Unsigned Architechture Range (like "usize"), found "u32".

For compatibility and comfort, arrays can have a number, and it'll be converted into an implicit range.

// Turns into an implicit range (`IMPLICIT(0..100)`).
//                    |
//                    V
let arr: array(bool, 100);

Using enums is also allowed:

enum Direction {
  North,
  South,
  East,
  West,
};

let direction_data: array(DirectionData, Direction);
PrintData(direction_data[North]);

However, you can't use floating-range types in arrays:

frange ArrayLimit = 100.0;

let the_boolean_pool: array(bool, ArrayLimit) = ...; // ERROR: An "frange" can't be used for an array range.

let the_boolean_sea: buf(bool, ArrayLimit) = ...; // ERROR: An "frange" can't be used for a buf range.