VSL
VSL copied to clipboard
✏️ VSL: Versatile, Safe, Language
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:
Windows | macOS | Linux |
---|---|---|
Download | Download | Download |
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 CompilationGroup
s. 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 });