Anyone wants a TS based scripting language?

[hydroper]

If anyone is interested into something similiar to TypeScript and that has types not erased at runtime and not requiring V8 optimizations such as property caching, I've done the type checker for VioletScript.

It's a generic language. Just missing codegen and LSP support.

• VioletScript: Quick Tour
  • Website root
  • Full Docs

GDScript uses reference-counting; I've designed VioletScript for a garbage collected environment. If needed I could change that.

VioletScript has:

• a simple but still good enough type system (unions, tuples, generic types, type aliasing, record types etc.),
• easy-to-optimize code and
• JSX-based markup works for any type without the need of a compiler transformer.

Type inference is similiar to CSharp and Java. Unlike TypeScript, Haxe and various functional languages there is no:

• Hindley Milner type system
• Bidirectional type checking

But there is type inference just like in CSharp and Java for certain cases, like lambdas, variable initializers and enum variants.

Enums

enums are safe and flexible:

• Variant type inference
• Define custom properties and methods (instance and static)
• Enums don't mix with numbers

const e: E = 'someVariant'
const e: E = E.SOME_VARIANT // equivalent to above
e.valueOf() // number value
e.toString() // 'someVariant'

const f: F = ['flag1', 'flag2']
const f: F = F(F.FLAG_1.valueOf() | F.FLAG_2.valueOf()) // equivalent to above

const f = f.toggle('flag1')
trace('flag1' in f)

Compile-time safety

E.g. uniting a type to undefined and/or null causes a compile-time error if you try accessing a property from a specific type.

var o: undefined | RegExp
o.source // undefined property 'source' on base undefined | RegExp
o!.source
o?.source

Maps (hash maps)

Everything is covered in the VioletScript docs, but you've all flexibility you've in GDScript. You can use object initializer for various types, including Map; e.g.:

this._sublayer.open({ character });

class Sublayer {
    function open(data: Map.<*, *>): void {
        const { character } = data;
    }
}

In this case, the character key turns into a string literal, which is then implicitly converted to the any type.

Etc.

Various features from ECMAScript and TypeScript:

• Destructuring patterns (record and array)
• import.meta
• Arrow functions

Here is the compiler draft. This .NET project is named "parser", but contains type checker and semantic data model together. In the AST you can see some SemanticN properties; they're not part of the node but a result of the compile-time verifier.

[fire]

I'm confused? why not quickjs? https://github.com/Geequlim/ECMAScript

[hydroper]

I've been uncertain since it's inactive and is currently at Godot 3.

[fire]

https://github.com/Geequlim/ECMAScript is now on Godot Engine 4.0

[hydroper]

I've done the type checker, now only codegen and LSP remaining.

dotnet run -- foo.vs

foo.vs:

var o: {x: Number} = {};
var {x} = o;
trace('hi');

foo.vs:1:22: VerifyError: Error #189: Object initializer must initialize the field 'x'
foo.vs:3:1: VerifyError: Error #128: 'trace' not found