Introducing new keyword type for anything which goes into type table for either type-checking or type inference.
Record Types
There will be record for data structure declaration.
Therefore:
type point = record {
var x : float;
var y : float;
}
Also developers can define operator functions using condition statements:
type point = record {
var x : float;
var y : float;
== => function(other:point) : bool {
return (x == other.x) && (y == other.y);
}
[] => function(index:int) : float {
return branch {
index == 0 => return x;
index == 1 => return y;
otherwise => return float.NaN;
}
}
[] => function(index:int, value:float) : void {
branch {
index == 0 => x = value;
index == 1 => y = value;
otherwise => nop;
}
}
}
So therefore a check like:
var p1 : point = {
x = 1;
y = 2;
}
var p2 : point = {
x = 2;
y = 2;
}
printf("%b\n", p1 == p2); // false
printf("%b\n", p1 < p2); // error: operation type(point) < type(point) is not implemented.
Generic Records
A generic record can be defined like this:
type tpoint = record : T1, T2 {
var x : T1;
var y : T2;
}
var p : tpoint<int, int> = {
x = 1;
y = 2;
}
var p2 : tpoint<string, string> = {
x = "12";
y = "13";
}
Record Functions
Functions can be included in a record with field, anything which does not need setting when introducing a record can be defined as field.
type point = record {
var x : Float;
var y : Float;
field distance = function(other:point) : float {
var dx = x - other.x;
var dy = y - other.y;
return math.sqrt( dx*dx + dy*dy );
}
}
var p1 : point = {
x = 2;
y = 3;
}
var p2 : point = {
x = 5;
y = 6;
}
p1.distance(p2); // 4.24264
Enum Types
So enumeration types are the same as any enumeration type yet they can have underlaying type.
type invalidation_flag = enum : int {
Text = 1;
Color = 2;
Size = 4;
All = Text | Color | Size;
}
var flag1 : invalidation_flag = 1; // Valid
var flag2 : invalidation_flag = Color; // Valid
var flag3 : invalidation_flag = flag1 | flag2; // Valid
flag3 == 3; // true
var flag4 : int = All; // Invalid: All is not of type int
By default enums inherit int types and start from 0.
Union Types
Union type can only accept one of the underlaying types and it's size is the biggest value inside the union declaration.
type some_type = record {
var x : int;
}
type number = union {
var x : int;
var y : float;
var z : double;
var n : some_type;
}
var a : number.x = 12;
var b : number.y = 0.2;
var c : number.z = 0.2;
0.2 == b; // true
c == b; // false
c.x; // 0 : double -> int conversion
a.z; // 12.0: int -> double conversion
a.n; // throw error: no viable conversion between int -> some_type.
Function Type
We can have function types when binding to a variable:
var x = function(a:int, b:int):double {
return double(a + b);
}
type of x is now a function with underlaying type of:
int->int->double
type ftype = function (int, int) : double;
var m = function(a:ftype, d:double):double {
return a(1, 2) + d;
}
// type of m : ftype->double->double
m(x, 3); // 6.0
Top comments (0)