moving all js docs under "javascript" (#368)

This commit is contained in:
Peli de Halleux
2017-03-07 10:17:01 -08:00
committed by Abhijith Chatra
parent bc1e5f2522
commit 316d82a8d2
32 changed files with 101 additions and 132 deletions

58
docs/javascript/call.md Normal file
View File

@ -0,0 +1,58 @@
# Call a function
The simplest way to get started in JavaScript with your @boardname@ is to
call one of the @boardname@'s built-in JavaScript functions. Just like Blocks
are organized into categories/drawers, the @boardname@ functions are organized by
namespaces, with names corresponding to the drawer names. The `basic` namespace
contains a number of helpful functions, such as:
```typescript
basic.showString("Hello!")
```
If you want to see all functions available in the `basic` namespace, simply type `basic`
followed by `.` and a list of all the functions will appear.
![](/static/mb/js/basicFuns.png)
This feature is known as "Intellisense". Continue typing to select one of the functions,
or click on one of the functions to select. You also narrow down the set of functions by typing, as below:
![](/static/mb/js/basicIntell.png)
You can type anything to see what Intellisense will find for you. Here's an example
of what happens when you type the word `for`:
![](/static/mb/js/forIntell.png)
## Function parameter values
You might have noticed that the call `showString` above takes one parameter value,
the string to be scrolled on the LED screen. There is a second (optional)
parameter that controls the speed of the scroll. Try this:
```typescript
basic.showString("Hello!",50)
```
Intellisense shows all the available parameters for a function.
## Left and right parentheses, please!
Whenever you want to call a function, you give the name of the function
followed by `(` and ending with `)`. Inbetween the left and right
parentheses go the function arguments. If a function has zero arguments, you still
need the parentheses in order to call the function. For example
```typescript
basic.clearScreen()
```
It's a syntax error to have a left parenthesis without the "closing" right parenthesis:
```
basic.clearScreen(
```
### ~button /javascript/sequence
NEXT: Sequencing Commands
### ~

263
docs/javascript/classes.md Normal file
View File

@ -0,0 +1,263 @@
# Classes
Traditional JavaScript focuses on functions and prototype-based inheritance as the basic means of building up reusable components,
but this may feel a bit awkward to programmers more comfortable with an object-oriented approach, where classes inherit functionality
and objects are built from these classes.
Starting with ECMAScript 2015, also known as ECMAScript 6, JavaScript programmers will be able to build their applications using
this object-oriented class-based approach. TypeScript, allows you to use these techniques.
Let's take a look at a simple class-based example:
```typescript
class Greeter {
greeting: string;
constructor(message: string) {
this.greeting = message;
}
greet() {
return "Hello, " + this.greeting;
}
}
let greeter = new Greeter("world");
```
We declare a new class `Greeter`. This class has three members: a property called `greeting`, a constructor, and a method `greet`.
You'll notice that in the class when we refer to one of the members of the class we prepend `this.`.
This denotes that it's a member access.
In the last line we construct an instance of the `Greeter` class using `new`.
This calls into the constructor we defined earlier, creating a new object with the `Greeter` shape, and running the constructor to initialize it.
# Inheritance
In TypeScript, we can use common object-oriented patterns.
Of course, one of the most fundamental patterns in class-based programming is being able to extend existing classes to create new ones using inheritance.
Let's take a look at an example:
```typescript-ignore
class Animal {
name: string;
constructor(theName: string) { this.name = theName; }
move(distanceInMeters: number = 0) {
console.log(`${this.name} moved ${distanceInMeters}m.`);
}
}
class Snake extends Animal {
constructor(name: string) { super(name); }
move(distanceInMeters = 5) {
console.log("Slithering...");
super.move(distanceInMeters);
}
}
class Horse extends Animal {
constructor(name: string) { super(name); }
move(distanceInMeters = 45) {
console.log("Galloping...");
super.move(distanceInMeters);
}
}
let sam = new Snake("Sammy the Python");
let tom: Animal = new Horse("Tommy the Palomino");
sam.move();
tom.move(34);
```
This example covers quite a few of the inheritance features in TypeScript that are common to other languages.
Here we see the `extends` keywords used to create a subclass.
You can see this where `Horse` and `Snake` subclass the base class `Animal` and gain access to its features.
Derived classes that contain constructor functions must call `super()` which will execute the constructor function on the base class.
The example also shows how to override methods in the base class with methods that are specialized for the subclass.
Here both `Snake` and `Horse` create a `move` method that overrides the `move` from `Animal`, giving it functionality specific to each class.
Note that even though `tom` is declared as an `Animal`, since its value is a `Horse`, when `tom.move(34)` calls the overriding method in `Horse`:
```Text
Slithering...
Sammy the Python moved 5m.
Galloping...
Tommy the Palomino moved 34m.
```
# Public, private, and protected modifiers
## Public by default
In our examples, we've been able to freely access the members that we declared throughout our programs.
If you're familiar with classes in other languages, you may have noticed in the above examples
we haven't had to use the word `public` to accomplish this; for instance,
C# requires that each member be explicitly labeled `public` to be visible.
In TypeScript, each member is `public` by default.
You may still mark a member `public` explicitly.
We could have written the `Animal` class from the previous section in the following way:
```typescript-ignore
class Animal {
public name: string;
public constructor(theName: string) { this.name = theName; }
public move(distanceInMeters: number) {
console.log(`${this.name} moved ${distanceInMeters}m.`);
}
}
```
## Understanding `private`
When a member is marked `private`, it cannot be accessed from outside of its containing class. For example:
```typescript-ignore
class Animal {
private name: string;
constructor(theName: string) { this.name = theName; }
}
new Animal("Cat").name; // Error: 'name' is private;
```
TypeScript is a structural type system.
When we compare two different types, regardless of where they came from, if the types of all members are compatible, then we say the types themselves are compatible.
However, when comparing types that have `private` and `protected` members, we treat these types differently.
For two types to be considered compatible, if one of them has a `private` member,
then the other must have a `private` member that originated in the same declaration.
The same applies to `protected` members.
Let's look at an example to better see how this plays out in practice:
```typescript-ignore
class Animal {
private name: string;
constructor(theName: string) { this.name = theName; }
}
class Rhino extends Animal {
constructor() { super("Rhino"); }
}
class Employee {
private name: string;
constructor(theName: string) { this.name = theName; }
}
let animal = new Animal("Goat");
let rhino = new Rhino();
let employee = new Employee("Bob");
animal = rhino;
animal = employee; // Error: 'Animal' and 'Employee' are not compatible
```
In this example, we have an `Animal` and a `Rhino`, with `Rhino` being a subclass of `Animal`.
We also have a new class `Employee` that looks identical to `Animal` in terms of shape.
We create some instances of these classes and then try to assign them to each other to see what will happen.
Because `Animal` and `Rhino` share the `private` side of their shape from the same declaration of
`private name: string` in `Animal`, they are compatible. However, this is not the case for `Employee`.
When we try to assign from an `Employee` to `Animal` we get an error that these types are not compatible.
Even though `Employee` also has a `private` member called `name`, it's not the one we declared in `Animal`.
## Understanding `protected`
The `protected` modifier acts much like the `private` modifier with the exception that members
declared `protected` can also be accessed by instances of deriving classes. For example,
```typescript-ignore
class Person {
protected name: string;
constructor(name: string) { this.name = name; }
}
class Employee extends Person {
private department: string;
constructor(name: string, department: string) {
super(name);
this.department = department;
}
public getElevatorPitch() {
return `Hello, my name is ${this.name} and I work in ${this.department}.`;
}
}
let howard = new Employee("Howard", "Sales");
console.log(howard.getElevatorPitch());
console.log(howard.name); // error
```
Notice that while we can't use `name` from outside of `Person`,
we can still use it from within an instance method of `Employee` because `Employee` derives from `Person`.
A constructor may also be marked `protected`.
This means that the class cannot be instantiated outside of its containing class, but can be extended. For example,
```typescript-ignore
class Person {
protected name: string;
protected constructor(theName: string) { this.name = theName; }
}
// Employee can extend Person
class Employee extends Person {
private department: string;
constructor(name: string, department: string) {
super(name);
this.department = department;
}
public getElevatorPitch() {
return `Hello, my name is ${this.name} and I work in ${this.department}.`;
}
}
let howard = new Employee("Howard", "Sales");
let john = new Person("John"); // Error: The 'Person' constructor is protected
```
# Readonly modifier
You can make properties readonly by using the `readonly` keyword.
Readonly properties must be initialized at their declaration or in the constructor.
```typescript-ignore
class Octopus {
readonly name: string;
readonly numberOfLegs: number = 8;
constructor (theName: string) {
this.name = theName;
}
}
let dad = new Octopus("Man with the 8 strong legs");
dad.name = "Man with the 3-piece suit"; // error! name is readonly.
```
## Parameter properties
In our last example, we had to declare a readonly member `name` and a constructor parameter `theName` in the `Octopus` class, and we then immediately set `name` to `theName`.
This turns out to be a very common practice.
*Parameter properties* let you create and initialize a member in one place.
Here's a further revision of the previous `Octopus` class using a parameter property:
```typescript-ignore
class Octopus {
readonly numberOfLegs: number = 8;
constructor(readonly name: string) {
}
}
```
Notice how we dropped `theName` altogether and just use the shortened `readonly name: string` parameter on the constructor to create and initialize the `name` member.
We've consolidated the declarations and assignment into one location.
Parameter properties are declared by prefixing a constructor parameter with an accessibility modifier or `readonly`, or both.
Using `private` for a parameter property declares and initializes a private member; likewise, the same is done for `public`, `protected`, and `readonly`.

View File

@ -0,0 +1,172 @@
# Functions
Functions are the fundamental building block of programs. Here is the simplest
way to make a function that adds two numbers:
```typescript
// Named function
function add(x : number, y : number) {
return x + y;
}
basic.showNumber(add(1, 2))
```
### ~ hint
For the @boardname@, you must specify a [type](/javascript/types) for each function parameter.
### ~
Functions can refer to variables outside of the function body.
When they do so, they're said to `capture` these variables.
```typescript
let z = 100;
function addToZ(x: number, y: number) {
return x + y + z;
}
basic.showNumber(addToZ(1, 2))
```
Let's add a return type to our add function:
```typescript
function add(x: number, y: number): number {
return x + y;
}
```
TypeScript can figure the return type out by looking at the return statements, so you can optionally leave this off in many cases.
# Arrow Functions
Arrow functions (also known as "lamba" functions) are used extensively to provide event handlers for
many APIs. For example:
```typescript
input.onButtonPressed(Button.A, () => {
})
```
[Read more about arrow functions...](http://devdocs.io/javascript/functions/arrow_functions)
# Optional and Default Parameters
In TypeScript, the number of arguments given to a function has to match the number of parameters the function expects.
```typescript-ignore
function buildName(firstName: string, lastName: string) {
return firstName + " " + lastName;
}
let result1 = buildName("Bob"); // error, too few parameters
let result2 = buildName("Bob", "Adams", "Sr."); // error, too many parameters
let result3 = buildName("Bob", "Adams"); // ah, just right
```
In JavaScript, every parameter is optional, and users may leave them off as they see fit.
When they do, their value is `undefined`.
We can get this functionality in TypeScript by adding a `?` to the end of parameters we want to be optional.
For example, let's say we want the last name parameter from above to be optional:
```typescript-ignore
function buildName(firstName: string, lastName?: string) {
if (lastName)
return firstName + " " + lastName;
else
return firstName;
}
let result1 = buildName("Bob"); // works correctly now
let result2 = buildName("Bob", "Adams", "Sr."); // error, too many parameters
let result3 = buildName("Bob", "Adams"); // ah, just right
```
Any optional parameters must follow required parameters.
Had we wanted to make the first name optional rather than the last name, we would need to change the order of parameters in the function, putting the first name last in the list.
In TypeScript, we can also set a value that a parameter will be assigned if the user does not provide one, or if the user passes `undefined` in its place.
These are called default-initialized parameters.
Let's take the previous example and default the last name to `"Smith"`.
```typescript-ignore
function buildName(firstName: string, lastName = "Smith") {
return firstName + " " + lastName;
}
let result1 = buildName("Bob"); // works correctly now, returns "Bob Smith"
let result2 = buildName("Bob", undefined); // still works, also returns "Bob Smith"
let result3 = buildName("Bob", "Adams", "Sr."); // error, too many parameters
let result4 = buildName("Bob", "Adams"); // ah, just right
```
Default-initialized parameters that come after all required parameters are treated as optional, and just like optional parameters, can be omitted when calling their respective function.
This means optional parameters and trailing default parameters will share commonality in their types, so both
```typescript
function buildName(firstName: string, lastName?: string) {
// ...
}
```
and
```typescript
function buildName(firstName: string, lastName = "Smith") {
// ...
}
```
share the same type `(firstName: string, lastName?: string) => string`.
The default value of `lastName` disappears in the type, only leaving behind the fact that the parameter is optional.
Unlike plain optional parameters, default-initialized parameters don't *need* to occur after required parameters.
If a default-initialized parameter comes before a required parameter, users need to explicitly pass `undefined` to get the default initialized value.
For example, we could write our last example with only a default initializer on `firstName`:
```typescript-ignore
function buildName(firstName = "Will", lastName: string) {
return firstName + " " + lastName;
}
let result1 = buildName("Bob"); // error, too few parameters
let result2 = buildName("Bob", "Adams", "Sr."); // error, too many parameters
let result3 = buildName("Bob", "Adams"); // okay and returns "Bob Adams"
let result4 = buildName(undefined, "Adams"); // okay and returns "Will Adams"
```
# Rest Parameters
Required, optional, and default parameters all have one thing in common: they talk about one parameter at a time.
Sometimes, you want to work with multiple parameters as a group, or you may not know how many parameters a function will ultimately take.
In JavaScript, you can work with the arguments directly using the `arguments` variable that is visible inside every function body.
In TypeScript, you can gather these arguments together into a variable:
```typescript-ignore
function buildName(firstName: string, ...restOfName: string[]) {
return firstName + " " + restOfName.join(" ");
}
let employeeName = buildName("Joseph", "Samuel", "Lucas", "MacKinzie");
```
*Rest parameters* are treated as a boundless number of optional parameters.
When passing arguments for a rest parameter, you can use as many as you want; you can even pass none.
The compiler will build an array of the arguments passed in with the name given after the ellipsis (`...`), allowing you to use it in your function.
The ellipsis is also used in the type of the function with rest parameters:
```typescript-ignore
function buildName(firstName: string, ...restOfName: string[]) {
return firstName + " " + restOfName.join(" ");
}
let buildNameFun: (fname: string, ...rest: string[]) => string = buildName;
```
### ~button /javascript/types
NEXT: Types
### ~

View File

View File

@ -0,0 +1,23 @@
## Operators
The following JavaScript operators are supported for the @boardname@.
### ~hint
Note that for the @boardname@ all arithmetic is performed on integers, rather than floating point.
This also is true when simulating in the browser.
### ~
# Assignment, arithmetic and bitwise
* assignment operators - [read more](http://devdocs.io/javascript/operators/assignment_operators)
* arithmetic operators - [read more](http://devdocs.io/javascript/operators/arithmetic_operators)
* bitwise operators - [read more](http://devdocs.io/javascript/operators/bitwise_operators)
# Comparision and conditional
* comparison operators - [read more](http://devdocs.io/javascript/operators/comparison_operators)
* conditional operator - [read more](http://devdocs.io/javascript/operators/conditional_operator)
### ~button /javascript/statements
NEXT: Statements
### ~

View File

@ -0,0 +1,63 @@
# Sequencing
By calling one function after another, in sequence, you can create an animation:
```typescript
basic.showLeds(`
. # . # .
. . . . .
. . # . .
# . . . #
. # # # .
`);
basic.showLeds(`
. # . # .
. . . . .
. . . . .
. # # # .
# . . . #
`);
```
### The semicolon
In JavaScript, the semicolon (;) is used to terminate (or end) a statement. However, in most
cases, the semicolon is optional and can be omitted. So both code sequences below are
legal:
```typescript
basic.showNumber(1)
basic.showNumber(2)
```
```typescript
basic.showNumber(1);
basic.showNumber(2);
```
### The empty statement
In JavaScript, there is the concept of an *empty statement*, which is whitespace followed by
a semicolon in the context where a statement is expected.
So, the following code is an infinite loop
followed by a call to `showNumber` that will never execute:
```typescript-ignore
while(true) ;
basic.showNumber(1);
```
### ~hint
For the @boardname@, we don't allow a program to contain an empty statement, such as shown above.
If you really want an empty statement, you need to use curly braces to delimit an empty statement block:
```typescript
while(true) { }
basic.showNumber(1);
```
### ~
[Read more](http://inimino.org/~inimino/blog/javascript_semicolons) about semicolons in JavaScript.
### ~button /javascript/variables
NEXT: Variable Declarations
### ~

View File

@ -0,0 +1,32 @@
# Statements
The following JavaScript statements are supported for the @boardname@:
## Variable declarations
* `const` statement - [read more](http://devdocs.io/javascript/statements/const)
* `let` statement - [read more](http://devdocs.io/javascript/statements/let)
## Block-structured statements
* `{ }` block statement - [read more](http://devdocs.io/javascript/statements/block)
* `if-else` conditional statement - [read more](http://devdocs.io/javascript/statements/if...else)
* `while` loop - [read more](http://devdocs.io/javascript/statements/do...while)
* `do-while` loop - [read more](http://devdocs.io/javascript/statements/do...while)
* `for(;;)` loop - [read more](http://devdocs.io/javascript/statements/for)
* `switch` statement (on numbers only) - [read more](http://devdocs.io/javascript/statements/switch)
## Control-flow commands
* `break` statement - [read more](http://devdocs.io/javascript/statements/break)
* `continue` statement - [read more](http://devdocs.io/javascript/statements/continue)
* `return` statement - [read more](http://devdocs.io/javascript/statements/return)
* `debugger` statement for breakpoints - [read more](http://devdocs.io/javascript/statements/debugger)
## Labelling statements
* labelled statement - [read more](http://devdocs.io/javascript/statements/label)
* `default` statement - [read more](http://devdocs.io/javascript/statements/default)
### ~button /javascript/functions
NEXT: Functions
### ~

141
docs/javascript/types.md Normal file
View File

@ -0,0 +1,141 @@
# Types
For programs to be useful, we need to be able to work with some of the simplest units of data:
numbers, strings, structures, boolean values, and the like.
# Type Inference
In TypeScript, there are several places where type inference is used to provide type information when there is
no explicit type annotation. For example, in this code
```typescript
let x = 3;
let y = x + 3
```
The type of the `x` variable is inferred to be `number`. Similarly, the type of `y` variable also is inferred to be `number`.
This kind of inference takes place when initializing variables and members,
setting parameter default values, and determining function return types.
All the examples below give an example type annotation, but will work just the same without the annotation.
# Boolean
The most basic datatype is the simple true/false value, which is called a `boolean` value.
```typescript
let isDone: boolean = false;
```
# Number
### ~ hint
In JavaScript, `numbers` are floating point values.
However, for the @boardname@, `numbers` are integer values.
### ~
Integer values can be specified via decimal, hexadecimal and octal notation:
```typescript
let decimal: number = 42;
let hex: number = 0xf00d;
let binary: number = 0b1010;
let octal: number = 0o744;
```
# String
As in other languages, we use the type `string` to refer to textual data.
Use double quotes (`"`) or single quotes (`'`) to surround string data.
```typescript
let color: string = "blue";
color = 'red';
```
You can also use *template strings*, which can span multiple lines and have embedded expressions.
These strings are surrounded by the backtick/backquote (`` ` ``) character, and embedded expressions are of the form `${ expr }`.
```typescript
let fullName: string = `Bob Bobbington`;
let age: number = 37;
let sentence: string = `Hello, my name is ${ fullName }.
I'll be ${ age + 1 } years old next month.`
```
This is equivalent to declaring `sentence` like so:
```typescript
let fullName: string = `Bob Bobbington`;
let age: number = 37;
let sentence: string = "Hello, my name is " + fullName + ".\n\n" +
"I'll be " + (age + 1) + " years old next month."
```
# Array
Arrays allow you to work with an expandable sequence of values, addressed by an integer-valued index.
Array types can be written in one of two ways.
In the first, you use the type of the elements followed by `[]` to denote an array of that element type:
```typescript
let list: number[] = [1, 2, 3];
```
The second way uses a generic array type, `Array<elemType>`:
```typescript
let list: Array<number> = [1, 2, 3];
```
### ~hint
For the @boardname@, all elements of an array must have the same type.
### ~
# Enum
A helpful addition to the standard set of datatypes from JavaScript is the `enum`.
As in languages like C#, an enum is a way of giving more friendly names to sets of numeric values.
```typescript
enum Color {Red, Green, Blue}
let c: Color = Color.Green;
```
By default, enums begin numbering their members starting at `0`.
You can change this by manually setting the value of one of its members.
For example, we can start the previous example at `1` instead of `0`:
```typescript
enum Color {Red = 1, Green, Blue}
let c: Color = Color.Green;
```
Or, even manually set all the values in the enum:
```typescript
enum Color {Red = 1, Green = 2, Blue = 4}
let c: Color = Color.Green;
```
# Any
The TypeScript type `any` is not supported in the @boardname@.
# Void
`void` is the absence of having any type at all.
You may commonly see this as the return type of functions that do not return a value:
```typescript
function warnUser(): void {
basic.showString("This is my warning message");
}
```
Declaring variables of type `void` is not useful.
### ~button /javascript/classes
NEXT: Classes
### ~

View File

@ -0,0 +1,133 @@
# Variable Declarations
Declaring a variable should be done using the ``let`` keyword:
```typescript
let a = 10;
```
## ``var`` vs ``let``
Declaring a variable in JavaScript has always traditionally been done with the `var` keyword.
```typescript-ignore
var a = 10;
```
The `var` construct has some [problems](http://www.typescriptlang.org/docs/handbook/variable-declarations.html),
which is why `let` statements were introduced. Apart from the keyword used, `let` statements are written
the same way `var` statements are.
```typescript
let a = 10;
```
The key difference is not in the syntax, but in the semantics, which we'll now dive into.
### ~hint
### Use `let` instead of `var` to introduce a new variable.
### ~
## Block-scoping
When a variable is declared using `let`, it uses what some call *lexical-scoping* or *block-scoping*.
Unlike variables declared with `var` whose scopes leak out to their containing function,
block-scoped variables are not visible outside of their nearest containing block or `for`-loop.
```typescript
function f(input: boolean) {
let a = 100;
if (input) {
// Still okay to reference 'a'
let b = a + 1;
return b;
}
// Error: 'b' doesn't exist here
return b;
}
```
Here, we have two local variables `a` and `b`.
`a`'s scope is limited to the body of `f` while `b`'s scope is limited to the containing `if` statement's block.
Another property of block-scoped variables is that they can't be read or written to before they're actually declared.
While these variables are "present" throughout their scope, all points up until their declaration are part of their *temporal dead zone*.
This is just a sophisticated way of saying you can't access them before the `let` statement, and luckily TypeScript will let you know that.
```typescript-ignore
a++; // illegal to use 'a' before it's declared;
let a;
```
## Re-declarations
With `var` declarations, it doesn't matter how many times you declare your variables, you just get one:
```typescript
var x = 10;
var x = 20;
```
In the above example, all declarations of `x` actually refer to the *same* `x`, and this is perfectly valid.
This often ends up being a source of bugs. Thankfully, `let` declarations are not as forgiving.
```typescript
let x = 10;
let x = 20; // error: can't re-declare 'x' in the same scope
```
## Shadowing
The act of introducing a new name in a more deeply nested scope is called *shadowing*.
It is a bit of a double-edged sword in that it can introduce certain bugs on its own in the
event of accidental shadowing, while also preventing certain bugs.
For instance, imagine a `sumMatrix` function using `let` variables.
```typescript
function sumMatrix(matrix: number[][]) {
let sum = 0;
for (let i = 0; i < matrix.length; i++) {
var currentRow = matrix[i];
for (let i = 0; i < currentRow.length; i++) {
sum += currentRow[i];
}
}
return sum;
}
```
This version of the loop will actually perform the summation correctly because the inner loop's `i` shadows `i` from the outer loop.
Shadowing should *usually* be avoided in the interest of write clearer code, such as
```typescript
function sumMatrix(matrix: number[][]) {
let sum = 0;
for (let i = 0; i < matrix.length; i++) {
var currentRow = matrix[i];
for (let j = 0; j < currentRow.length; j++) {
sum += currentRow[j];
}
}
return sum;
}
```
While there are some scenarios where it may be fitting to take advantage of it, you should use your best judgement.
# `const` declarations
`const` declarations are another way of declaring variables.
```typescript
const numLivesForCat = 9;
```
They are like `let` declarations but, as their name implies, their value cannot be changed once they are bound.
In other words, they have the same scoping rules as `let`, but you can't re-assign to them.
### ~button /javascript/operators
NEXT: Operators
### ~