Type Declaration

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

Blog

Nevergarden