Welcome to TeaScript’s documentation!¶

Auto-Install Script¶

Install teascript from the GitHub

Give teascript the correct permissions

$ chmod +x teascript

Run teascript, and it should install the correct files. Enter the code, and then the input, , seperated.

1
2
3
4
5
6

  $ ./teascript
  TeaScript not installed. Installing TeaScript...
  # ...
  Code: # <TeaScript Code Here>
  Input: # <Input Here> e.g.: Input 1,Input 2,Input 3,...
  # <Output Here>

The next time you run TeaScript, it’ll detect the TeaScript/ folder and won’t need to reinstall the dependencies.

Manual Installation¶

You can also manually install/run TeaScript if you’re having issues with the script

Install the following files

• Everything within /src/v2
• sh.js from /src/sh/sh.js

Edit teascript.js and replace window with this, and /*props.json*/ with JSON.parse(read("props.json"))

Strings¶

They are three types of strings

"Double Quoted String Literal"
'Single Quoted String Literal'
`String templates`

String templates have a few extra features such as:

`String templates support inline
newlines and code such as ${2+1}`

Numbers¶

Numbers are also, just numbers:

12345 // Decimal
12.34 // Decimal
1e23) // Scientific Notation
0xFA) // Hexadecimal
0b10) // Binary
0o18) // Octal

RegExp¶

TeaScript has support for RegExp literals and they’re just the same as JavaScript

/[A-Za-z]/gi

By TeaScript 3.1, I hope to have XRegExp, implemented which should allow your RegExp literals to look like:

/\u{L}+/u

Functions¶

Functions are the same as JavaScript too.

(a,b,c)=>a+b+c // Arguments[a,b,c] adds them together
a=>a           // Single argument a, returns a

This is quite lengthy so I’ve added the # operator which automatically expands to (l,i,a,b)=> at compile time

#l+i+a  // Arguments[l,i,a,b] adds first 3

Input Options¶

The user can decide how (s)he wants the input. TeaScript supports all of the following input types:

• String (default)
• Number
• Array

Getting the Input¶

The input is stored in various variables:

Need More inputs? An array of all the inputs is stored in the _ variable.

If the input is an array, the 1st input will be split upon , and each item will become a seperate input. For the code:

Input 1,Input 2,Input 3

The values are:

Custom Character Classes¶

TeaScript adds custom character classes (e.g. \w) to a RegExp literal. These are esentially shorthands for character classes, an example

/[A-Za-z]/  // Before
/\L/        // After
/[A-Za-z]/  // At compile-time

# Operator¶

The # operator is one that is very useful. It’s a shorthand for function declerations that you can use where ever. # expands to (l,i,a,b)=>

(a,b,c,d)=>a+b+c+d // Before
#l+i+a+b           // After

@ Operator¶

The @ operator is similar to the # operator, but if you ever have two nested lambdas, you can use this. @ expands to (q,r,s,t)=>q.

(a,b,c,d)=>aT2)+b+d // Before
@T2)+r+t            // After

ƒ Operator¶

ƒ expands to f=(l,i,a,b)=>, this can be used to create recursive functions easily without having to manually add a decleration

f=(a,b)=>a<1?b:f(a--,b++); // Before
ƒl<1?i:f(l--,i++);         // After

Σ Operator¶

The Σ operator can be used to loop through arrays and strings, it expands to .l((l,i,a,b)=>.

xΣlc // Maps char codes
xΣi  // Generates range

? Operator¶

This operator has 2 uses depending on where you use it.

Interrupting Property expansion

If you ever need to use a JavaScript property name and TeaScript thinks it’s a TeaScript property, insert a ? after the property

x.search(/\A/) // JavaScript
x.search?/\A   // TeaScript

Closing Parenthesis

xl(#lT(2r("foo"[1]))) // Before
xl(#lT(2r("foo"[1?    // After

Shorthands¶

Using ƒ

This can be used to assign functions both recursive and not. To learn more about this operator, see ƒ Operator.

f=(l,i)=>l<1?i:f(l--,i++) // Before
ƒl<1?i:l--:i++            // After

f=l=>{for(i=0;i<l;i*=i)} // Before
ƒ{for(i=0;i<l;i*=i       // After

Assignment Operator¶

You an also just use the assignment operator to assign variables. Some one-letter variables are already preassigned so you may be able to skip the definition.

var i=0;  // Before
i=0;      // After

Removing Brackets¶

If you have a function, and then a literal, you can ommit the ( before it. You can also ommit ending ) and other brackets

MF(32) // Before
MF32   // After

MF(3,x[32]) // Before
MF3,x[32    // After

Removing Literal Endings¶

Endings of literal characters can be ommited, this includes Strings, RegExps, and Snippets.

"Foo"  // Before
"Foo   // After

`Foo`  // Before
`Foo   // After

/Fo{2}/ // Before
/Fo{2}  // After

Hello, World¶

Outputs Hello, World

"Hello, World!

cat¶

Outputs the input

x

Fibonacci¶

Given n this calculated the nth Fibonacci number

F(x

Primality Test¶

Calculates whether a given number is prime

mP(x

Cycling Arrays¶

Cycle an array 1 spots

xC1

Average of Numbers¶

Calculates the average of numbers

xx/xn

Syntax Errors¶

A syntax error starts with SyntaxError:, and is an error with the syntax itself, the error should display from where the error originated and by looking at the previous compilation steps, you may be able to identify where the error occured.

This error could of originated in any of the following compilation stages:

• String Balancing
• Unicode Shortcuts
• Property Expansion
• Paranthesis Balancing
• babel compilation

If you believe the error originated during babel compilation, report the error at babel’s Github.

Runtime Errors¶

Any other error is a JS runtime error which is usually caused by referencing a variable that doesn’t exist. Runtime errors are errors with the code itself rather than the syntax. Try to break down your code and try to identify where the error is originating. If you believe this error shouldn’t be happening, don’t hesitate to report it on Github.