TypeScript Syntax and Basic Types

// Explicit annotation
let count: number = 10;
let message: string = "Hello";

// Type inference (recommended when obvious)
let inferredCount = 10;        // number
let inferredMsg = "Hello";     // string

// Function with annotations
function add(a: number, b: number): number {
    return a + b;
}

// Contextual typing in callbacks
const numbers = [1, 2, 3];
numbers.map(num => num * 2);  // num inferred as number

// String types
let username: string = "Alice";
let template: string = `Hello ${username}`;

// Number types
let age: number = 30;
let price: number = 19.99;
let hex: number = 0xf00d;
let binary: number = 0b1010;

// Boolean
let isActive: boolean = true;
let hasPermission: boolean = false;

// Null and undefined
let nothing: null = null;
let notAssigned: undefined = undefined;

// Symbol
let uniqueId: symbol = Symbol("id");

// BigInt
let huge: bigint = 9007199254740991n;

// String literals
type Direction = "north" | "south" | "east" | "west";
let move: Direction = "north";

// Numeric literals
type HttpCode = 200 | 201 | 400 | 404 | 500;
let response: HttpCode = 200;

// Template literal types
type EventName = `on${Capitalize<string>}`;
type UserId = `user-${number}`;
type CSSProperty = `--${string}`;

// Practical template literal usage
type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE";
type Endpoint = `/${string}`;
type APIRoute = `${HTTPMethod} ${Endpoint}`;

let route: APIRoute = "GET /api/users";

// Basic arrays
let numbers: number[] = [1, 2, 3, 4];
let strings: Array<string> = ["a", "b", "c"];

// Multi-dimensional arrays
let matrix: number[][] = [[1, 2], [3, 4]];

// Readonly arrays
let immutable: readonly string[] = ["a", "b"];
// immutable.push("c"); // Error!

// Tuples
let coordinate: [number, number] = [10, 20];
let user: [string, number, boolean] = ["Alice", 30, true];

// Optional tuple elements
let response: [number, string?] = [200];
let fullResponse: [number, string?] = [200, "OK"];

// Rest elements in tuples
let data: [string, ...number[]] = ["label", 1, 2, 3];

// Labeled tuples
type Point = [x: number, y: number];
let point: Point = [10, 20];

// Basic object type
let user: { name: string; age: number } = {
    name: "John",
    age: 30
};

// Optional and readonly properties
let config: {
    host: string;
    port?: number;
    readonly apiKey: string;
} = {
    host: "localhost",
    apiKey: "abc123"
};

// Index signatures
let scores: { [student: string]: number } = {
    "Alice": 95,
    "Bob": 87
};

// Mixed: defined properties + index signature
type Dictionary = {
    count: number;  // known property
    [key: string]: number;  // dynamic keys
};

// Nested objects
let company: {
    name: string;
    address: {
        street: string;
        city: string;
    };
} = {
    name: "TechCorp",
    address: { street: "Main St", city: "NYC" }
};

// Basic union
let id: string | number;
id = "ABC123";  // OK
id = 42;        // OK

// Union with null
function find(name: string): User | null {
    return database.find(name) ?? null;
}

// Discriminated union (tagged union)
type Success = { status: "success"; data: any };
type Error = { status: "error"; message: string };
type Result = Success | Error;

function handle(result: Result) {
    if (result.status === "success") {
        console.log(result.data);  // Type narrowed to Success
    } else {
        console.log(result.message); // Type narrowed to Error
    }
}

// Basic intersection
type Person = { name: string; age: number };
type Employee = { employeeId: string; department: string };
type Worker = Person & Employee;

let worker: Worker = {
    name: "John",
    age: 30,
    employeeId: "E123",
    department: "IT"
};

// Mixin pattern with intersections
type Timestamped = { createdAt: Date; updatedAt: Date };
type Versioned = { version: number };
type Document = { id: string; content: string };

type FullDocument = Document & Timestamped & Versioned;

// any - no type safety
let data: any = getUserInput();
data.anything();        // No error, dangerous!
data.toUpperCase();     // Runtime error if not string

// unknown - type-safe
let safeData: unknown = getUserInput();
// safeData.anything(); // Error! Must check first

if (typeof safeData === "string") {
    safeData.toUpperCase(); // OK, narrowed to string
}

// void - function completes but returns nothing
function log(message: string): void {
    console.log(message);
    // implicitly returns undefined
}

// never - function never returns
function throwError(message: string): never {
    throw new Error(message);
    // execution stops here
}

function infiniteLoop(): never {
    while (true) {
        // never exits
    }
}

// never in exhaustive checks
type Shape = "circle" | "square";
function assertNever(x: never): never {
    throw new Error("Unexpected: " + x);
}

function getArea(shape: Shape): number {
    switch (shape) {
        case "circle": return 1;
        case "square": return 2;
        default: return assertNever(shape); // Compile error if not exhaustive
    }
}