ti2c

is a{T}yping, {I}mmuting, {I}nterning and {C}aching framework for Javascript ti2c is designed to facilitate robust coding and improve performance with caching avoiding deep copy or protective copying of data structures.

a minimal working example

Following code can be downloaded from https://gitlab.com/ti2c/ti2c/-/tree/examples.

src/Point.js

Defines point as a ti2c class having two attributes. Also a function to add to points is defined.

def.attributes =
{
    x: { type: 'number' },
    y: { type: 'number' },
};

def.proto.add =
    function( p )
{
    return Self.create( 'x', this.x + p.x, 'y', this.y + p.y );
};

Currently ti2c follows a one class per file rule.

src/Root.js

Not lets use the "Point class". Since this file does not define a class to b einstanced it is declared to be "abstract".

Also the import syntax ti2c uses to import another ti2c class can be seen using {} in the import string.

def.abstract = true;

import { Self as Point } from '{Point}';

def.static.run =
    function( )
{
    const p1 = Point.create( 'x', 1, 'y', 2 );
    const p2 = Point.create( 'x', 1, 'y', 2 );
    const p3 = Point.create( 'x', 2, 'y', 4 );
    console.log( 'equal?', p1 === p2 );
    console.log( 'equal?', p1 === p3 );
    console.log( 'equal?', p1.add( p2 ) === p3 );
};

src/Start.js

Finally a ti2c application needs a starting driver running in the default node context.

global.CHECK = true;
await import( 'ti2c' );
const pkg =
  await ti2c.register(
    'name', 'example',
    'meta', import.meta,
    'source', 'src/',
    'relPath', 'Start',
    'codegen', 'codegen/'
  );
const Root = await pkg.import( 'Root' );
Root.run( );

Now we can run the example. Note that currently --experimental-vm-modules is needed as node parameter, since ti2c uses the esm vm module.

$ node --experimental-vm-modules src/Start.js

The output is: equal? true equal? false equal? true

p1 added to p1 returns the object that is also p2.

lazy evaluation

ti2c supports lazy evaluation and caching of the results. Lets enhance previous Point function with two lazy evaluated attributes, first the length from Point 0/0 as "length" as well a distance to another point.

src/Point.js

def.attributes =
{
    x: { type: 'number' },
    y: { type: 'number' },
};

def.lazy.length =
  function( )
{
    console.log( 'calculating length...' );
    const x = this.x;
    const y = this.y;
    return Math.sqrt( x * x + y * y );
};

def.lazyFunc.distanceTo =
  function( p )
{
    console.log( 'calculating distance...' );
    const dx = this.x - p.x;
    const dy = this.y - p.y;
    return Math.sqrt( dx * dx + dy * dy );
};

and now again a test program:

src/Root.js

def.abstract = true;

import { Self as Point } from '{Point}';

def.static.run =
    function( )
{
    const p1 = Point.create( 'x', 1, 'y', 2 );
    const p2 = Point.create( 'x', 2, 'y', 4 );
    console.log( 'p1 length is', p1.length );
    console.log( 'p1 length is', p1.length );
    console.log( 'p1-p2 distance is', p1.distanceTo( p2 ) );
    console.log( 'p1-p2 distance is', p1.distanceTo( p2 ) );
};

the output is

calculating length...
p1 length is 2.23606797749979
p1 length is 2.23606797749979
calculating distance...
p1-p2 distance is 2.23606797749979
p1-p2 distance is 2.23606797749979