TiScript - Turing-Incomplete TypeScript as a Configuration Language

TiScript is a configuration language designed to be intuitive and easy for humans and machines. It draws inspiration from TypeScript and JSON, offering the benefits of both:

Readability and maintainability for humans, similar to JSON.
Type safety and structure for machines inspired by TypeScript.

TiScript is intentionally designed to be Turing incomplete. This means it focuses on defining configurations and is not intended for general programming tasks. However, since it's a subset of TypeScript, you can still leverage the TypeScript development toolkit for features like language services.

Project Status

This is a work in progress. The current implementation is MVP and not intended to be used in production.

Example

TiScript definition (it's strict subset of TypeScript):

// editor_config.ts
const LF = "\x0A";

export const tabSize = 4;
export const trimTrailingWhitespace = true;
export const endOfLine = LF;
export const encoding = "utf-8";

Currently, the only interface is a command called tiscript(1) (or cargo run on development).

$ cargo run ./editor_config.ts

the output is:

{
    "tabSize": 4,
    "trimTrailingWhitespace": true,
    "endOfLine": "\n",
    "encoding": "utf-8"
}

Rust API

This library implements serde's Deserializer.

Synopsis

From a file:

use serde::{Deserialize, Serialize};

use tiscript::from_file;

// integrated to Serde
#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct EditorConfig {
    tabSize: i32,
    trimTrailingWhitespace: bool,
    endOfLine: String,
    encoding: String,
}

fn main() {
    let editorConfig: EditorConfig = from_file("./editor_config.ts").unwrap();
    // or from_file_with_timeout(f, d) for untrusted code

    println!("{:?}", editorConfig);
}

From an inline code:

use serde::{Deserialize, Serialize};

use tiscript::from_str;

// integrated to Serde
#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct EditorConfig {
    tabSize: i32,
    trimTrailingWhitespace: bool,
    endOfLine: String,
    encoding: String,
}

fn main() {
    let editorConfig: EditorConfig = from_str(r#"
        const LF = "\x0A";

        export const tabSize = 4;
        export const trimTrailingWhitespace = true;
        export const endOfLine = LF;
        export const encoding = "utf-8";
    "#).unwrap();
    // or from_str_with_timeout(f, d) for untrusted code

println!("{:?}", editorConfig);
}

Description

TBD

Features

This is a list of features in ECMA-262 that are planned or implemented ("[x]" does not necessarily mean it's 100% compatible with TypeScript and ECMA-262):

This is a list of features in TypeScript that are planned or implemented:

This is a list of features that won't be implemented:

var declaration
eval function
new Function()
RegExp and regular expression operators
Most of runtime (e.g. typed arrays)
for-in loop
async and await
symbol
true bigint
decorators (just because the spec is too large)
enum
const enum
namespace
commonjs features
no strict features
unlimited recursion / loop
anything that meets Turing completeness

Note that any features TiScript recognizes, but TypeScript compiler does not are invalid, but not vice versa. This is because TiScript is a strict subset of TypeScript.

Development

If you'd like to develop this project, run UPDATE=1 cargo test to automatically generates *.stdout or *.stderr files in spec/.

WebAssembly

This project is ensured to be built with --target=wasm32-wasi in CI. There's no test for WebAssembly though.

Similar Works

JSON https://www.json.org/
Jsonnet https://jsonnet.org/
TySON https://github.com/jetify-com/tyson

Authors

FUJI, Goro (gfx).

This project a fork of https://github.com/msakuta/ruscal, and thus much of the code comes from it.

License

This project is licensed under the ISC License - see the LICENSE file for details.

gfx/tiscript