Concept for the Kipper Runtime Type System

[Luna-Klatzer]

Concept for the Kipper Type Runtime System

This is a possible implementation of the Kipper Type Runtime system, which will implement a different behaviour than JavaScript or TypeScript to ensure type cohesion and security.

Primitive Types

Since Kipper is a language that will primarily translate to JavaScript and TypeScript, the type system of Kipper will strictly be limited to the existing primitive types that exist and changes may only add, but not remove any type, since doing otherwise would immediately break any compatibility between Kipper and JS/TS files.

As such, the runtime types of Kipper will simply inherit the behaviour from JavaScript, but extend it with additional functionality using the Kipper Compiler and runtime additions. This means explicitly that Kipper will implement runtime type objects to represent these primitive types, which can also then be referenced in Kipper code using their identifier.

For example, the type identifier used to specify the type of a variable will be the same as the referencable type identifier:

var x: num = 5;

typeof(x); // -> 'num'
typeof(num); // -> 'type'

typeof(x) == num; // -> true

To that, like with the constructors in JavaScript, you may use the types as a way to explicitly convert them to a specified type, for example:

var testNum: num = num("123"); // -> 123

The Type parent class

To implement these runtime type objects, a built-in class called Type will be implemented, which will provide the standard implementation of a runtime type. This can also then be used as the type for storing a type, like for example:

var numType: Type = num;

This class will also provide the following fields:

class Type {
  name: str; // Standard Kipper type name
  native: str; // Native JavaScript type name
  constructor: obj | undef; // Native JavaScript constructor, which allows the creation of a primitive inside a wrapped object
  match: (val: any) => bool; // Function, which will be used for runtime checks and the 'match' keyword in the future
}

Detailed List of types

Kipper Type	TS Name	JS Constructor
null	null	❌
void	undefined	❌
undef*	undefined	❌
num	number	Number
str	string	String
bool	boolean	Boolean
bigint	bigint	BigInt
obj	object	Object

*As of release v0.10.3, undef is called undefined, but that may change with the next release to simplify the base primitive types to be collectively shorter.

Additional Reference

• Kipper Runtime Types Proof of Concept #332

[Luna-Klatzer]

Important related issues:

• [Feature] Implement built-in Kipper types objects #369
• [Feature] Implement support for built-in type identifiers such as str, num, bool etc. #495