TypeScript Output

This is a living document to assemble product requirements for potential TypeScript output from the CoffeeScript compiler.

If the CoffeeScript compiler were to output TypeScript source code, similar to the way it outputs JSX now, what TypeScript syntax should it support?

It’s a separate question what CoffeeScript syntax will be designed to support each TypeScript syntax; for now we just want to create a list of output syntax that we eventually want to support.

Type Annotations

function greeter(person: string) {}

class Student {
  fullName: string;
  constructor(public firstName: string, public middleInitial: string, public lastName: string) {}
}

let list: Array<number> = [1, 2, 3];

Type Assertions

const myCanvas = document.getElementById("main_canvas") as HTMLCanvasElement;
const myCanvas = <HTMLCanvasElement>document.getElementById("main_canvas");

Nonnull assertion

function liveDangerously(x?: number | undefined) {
  // No error
  console.log(x!.toFixed());
}

Type Predicates

function isFish(pet: Fish | Bird): pet is Fish {
  return (pet as Fish).swim !== undefined;
}

Generic Functions

function firstElement<Type>(arr: Type[]): Type {
  return arr[0];
}

Function Overloads

function makeDate(timestamp: number): Date;
function makeDate(m: number, d: number, y: number): Date;
function makeDate(mOrTimestamp: number, d?: number, y?: number): Date {
  if (d !== undefined && y !== undefined) {
    return new Date(y, mOrTimestamp, d);
  } else {
    return new Date(mOrTimestamp);
  }
}
const d1 = makeDate(12345678);
const d2 = makeDate(5, 5, 5);

Interfaces

interface Person {
  firstName: string;
  lastName: string;
}

Composing Types

type WindowStates = "open" | "closed" | "minimized";
type BotId = string | number

Enum

enum BooleanLikeHeterogeneousEnum {
  No = 0,
  Yes = "YES",
}

Optional Parameters

function buildName(firstName: string, lastName?: string) {
  if (lastName) return firstName + " " + lastName;
  else return firstName;
}

Public, private, and protected modifiers

class Animal {
  private id: string;
  protected name: string;
  public constructor(theName: string) {
    this.name = theName;
  }
  public move(distanceInMeters: number) {
    console.log(`${this.name} moved ${distanceInMeters}m.`);
  }
}

Readonly modifier

class Octopus {
  readonly name: string;
  readonly numberOfLegs: number = 8;
  constructor(theName: string) {
    this.name = theName;
  }
}

Accessors (ES6)

class Employee {
  private _fullName: string;

  get fullName(): string {
    return this._fullName;
  }

  set fullName(newName: string) {
    if (newName && newName.length > fullNameMaxLength) {
      throw new Error("fullName has a max length of " + fullNameMaxLength);
    }
    this._fullName = newName;
  }
}

Abstract Classes

abstract class Animal {
  abstract makeSound(): void;
  move(): void {
    console.log("roaming the earth...");
  }
}

class Cat extends Animal {
  constructor() {
    super("I'm a cat"); // constructors in derived classes must call super()
  }
  makeSound(): void {
    console.log('Meowwww')
  }
}

Declaration

declare global {
  interface Array<T> {
    toObservable(): Observable<T>;
  }
}

Array.prototype.toObservable = function() {
  ...
};