📃 Docs

A step-by-step guide to mastering Boron programming language. We will look at all (literally) the features, functions and properties of Boron Programming language.

Index

Basics

Boron is a cross-platform, easy to learn, fast and light weight programming language made for fun. Boron interpreter is available for Windows, MacOS and Linux.

Boron is dynamically typed and assigns the variable type at runtime depending on the value provided.

• Installation

• Prerequisites

Requires NodeJS, pkg, yarn, typescript compiler (tsc) for building.

[filename] -> replace a .bor file (use ./test/main.bor for testing) or leave it empty for entering repl more

• Windows [Not Tested]

git clone https://github.com/nav343/Boron.bor.git
cd ./Boron.bor
yarn        # to install all the packages to ./node_modules
tsc         # compile ts to js
yarn build

# This will create a dist/build folder.
./dist/build/boron-win.exe [filename or '']

• Linux

git clone https://github.com/nav343/Boron.bor.git
cd ./Boron.bor
yarn        # to install all the packages to ./node_modules
tsc         # compile ts to js
yarn build

./dist/build/boron-linux [filename or '']

• Mac OS [Not Tested]

git clone https://github.com/nav343/Boron.bor.git
cd ./Boron.bor
yarn        # to install all the packages to ./node_modules
tsc         # compile ts to js
yarn build

./dist/build/boron-macos [filename or '']

Types

Boron has 5 types which are string, boolean, number, null and object

As mentioned above, boron is a dynamically typed programming language, so you don't need to specify any of the above types, boron automatically assigns the type at runtime.

You can check the variable's type by using the typeof() native function

Variables

In programming, a variable is a value that can change, depending on conditions or on information passed to the program. In boron, variables can be assigned using either the let keyword or the const keyword.

Variables assigned with the let are mutable meaning that their value can be changed and variables assigned with the const keyword are immutable meaning that their value cannot be changed, no variable can be re-assigned but their values can be changed (only if it is mutable).

Variable value can be of type int, float, string or object.

int stands for Integers and can store integer values, like 10, 12332, etc (note that -ve numbers are not supported at the moment)

float stands for floating point numbers and can store decimal (.) values, like 123.2, 123.12312, etc

string as the name suggests, stores string values (enclosed in "), like "hi there". At the moment boron only supports "___". String can be multi line or single line.

object stores key value pairs, like { name: "nav343" }, here "name" is the key and "nav343" is the value, the value can be of any type. Short hand values are valid, for example:

const name = "nav343";
const info = {
  name,
  age: 1
};

Later you can access name by info::name and age by info::age

Example:

$ this value can be modified
let intVar = 1234;

$ this cannot be modified
const floatVar = 234.3243;

let name = "nav343";
name = "nice name nav343"
let shortHandName = "nice name";

const info = {
  name: "nicename",
  age: 123456,
  shortHandName
};
print(info::name, info::age, info::shortHandName)

Functions

A function is simply a “chunk” of code that you can use over and over again, rather than writing it out multiple times. In boron you can use the func keyword, followed by an identifier and then by the body, to declare a function. For example -

func welcomeNewUser(name, otherInfo) {
  print(name)
  print(otherInfo)
}
const otherInfo = {
  age: 123,
  hobby: "making languages"
};

welcomeNewUser("nav343", otherInfo::age)
welcomeNewUser("nav343", otherInfo::hobby)

Here welcomeNewUser is a function which takes in 2 arguments - name and otherInfo, notice how you don't need to specify a type of these arguments.

Now you can use these 2 variables anywhere inside that function scope (inside those {...} basically).

For calling the function, you just have to type the name, followed by parentheses and arguments inside them (if any). Arguments are separated by commas ,

Native Functions

Some functions in boron programming language are reserved and are provided out of the box and can be used anywhere inside your project without needing to import any other file(s). Here is the list of all (that are available in the latest version) the built-in functions/ native functions -