Language Documentation — API Documentation

Versatile Scripting Language

VSL is a modern, powerful, fast, and easy to write programming language designed for the 21st century.

Download

You can either build from source (see Building) or installed a pre-compiled binary/executable:

Changes

Git revision history is a mess but checkout CHANGELOG.md for detailed devleopment information.

Building

Building isn't too diffiult. Usually you'll want to install a pre-built binary but if you're feeling adventurous or just want to help build VSL (:D) building from source is simple:

$ git clone --recursive https://github.com/vsl-lang/VSL
$ npm install
$ npm run build

Do note, branch of the develop branch to make changes. All PRs go there. Other commands:

$ npm run coverage # Generates testing coverage reports
$ npm test         # Runs all tests
$ npm run dev      # Development build
$ npm run docs     # Make docs
$ npm run lint     # Lint code and make sure not crap

Do note you don't need to generate docs unless you want them for yourself because the CI will automatically generate docs.

Development Info

• Docs are located here.
• A bunch of READMEs are located in the dirs which do more complex things

Problem

Today they are quite a few languages, some popular ones you may of heard of are:

• Python
• Java
• JavaScript
• C/C++

and while these are all great and well (and have worked). Here are the things one wants from a programming language:

• Portability (C/C++ lack here)
• Ease of Use (Java & C/C++ lack here, but arguable)
• Rapid prototyping (Java, C/C++, and even JS ES2015+)
• Saftey: type, memory, etc. (JS & Python lack)
• Bare-metal speed (yeah...)
• Powerful and close-to-hardware (JS, Python, and Java lack)

So VSL aims to solve all of these problems

• Portability: By leveraging the LLVM bytecode engine VSL can compile to almost all targets and is designed for simple compatibility with existing C projects.

• Fast: Due to careful design and implementation choices, VSL compiles to very similar ASM to what something written in a low-level language such as C would produce.

• Safe: By using syntax sugar, and powerful type-negotiation, VSL has one of the best type deduction algorithms. Combined with low compilation overhead, VSL can generate code with bare minimum boilerplate and guarunteed saftey at compile-time.

• Powerful: VSL uses high-level syntax to be able to write code that works for all types of programmers, whether you are functional, OO, scripting, or low-level engineer. Through both high-level interfaces for low-level functions, you can use VSL for tasks low-level such as read/writing bits from a serial port to running a server.

• Reliability: through bindings of reliable, trusted, and industry-standard libraries such as libcurl, and libc backends, VSL has powerful low-level pointer interopability and the power of full OO-classes.

Examples

VSL functions both as a scripting and a full-blown language so two alterntaives are given for all programs. That said, they are many more ways to write many of these programs, neither more correct than the other.

Hello, World!

print("Hello, World")

func main(args: String[]) {
  print("Hello, World!")
}

Fizzbuzz

let fizzbuzz :: (of: Int) -> String
fizzbuzz(i where i % 3, i % 5) -> "FizzBuzz"
fizzbuzz(i where i % 3) -> "Fizz"
fizzbuzz(i where i % 5) -> "Buzz"
fizzbuzz(i) -> String(for: i)

Using the JS interface

To interface with the compiler the easiest way is to use the VSLToolchain class. For more specific behavior you'd need to interact directly with the CompilationIndex and CompilationGroups. See the documentation for information on that:

import { Toolchain } from 'vsl';

const toolchain = new Toolchain.VSLToolchain();

const file = {
    type: Toolchain.VSLToolchainDataSourceType.file,
    data: './main.vsl'
};

const compilationInstance = await toolchain.executeFiles([ file ]);
const emissionInstance = await result.compile();

// Get byte-code
const byteCode = await emissionInstance.emitRaw(result);

// To obtain an executable
await compiledInstance.emitExecutable('main.out', { /* See object options below */ });

// To obtain a shared object
await compiledInstance.emitSharedObject('main.dylib', { /* See object options below */ });

// To obtain a linked object file
await compiledInstance.emitObject('main.o', { optimizationLevel: 3, objects: [...], libraries: [...] })

// Otherwise to optimize and get bytecode
await compiledInstance.emitBitcode('main.bc', { optimizationLevel: 3 });

// To obtain assembly
await compiledInstance.emitAsm('main.s', { optimizationLevel: 3 });