// Primitive Type Alias: basic data type
// ID can be either a string or a number, making it easier to manage variables that can hold both types.
type ID = string | number;


// Object Type: structured data type composed of key-value pairs
// This defines Point as an object type with x and y properties, both of which are numbers. This can be particularly useful when dealing with coordinates in a 2D space.
type Point = {
  x: number;
  y: number;
};


// Union Type:  hold values of different specified types
// The Status type can be one of the specified string literals, making it easy to handle different states of an operation.
type Status = "success" | "failure" | "pending";


// Intersection Type: combines multiple types into one
// This combines the properties of Name and Contact into a single type Person, which includes both personal and contact information.
type Name = {
  firstName: string;
  lastName: string;
};

type Contact = {
  email: string;
  phone: string;
};

type Person = Name & Contact;

// Struct: For defining object-like structures.
// This defines a Point struct with x and y properties.
struct Point {
    var x: Int
    var y: Int
}


// Typealias: For creating type aliases.
// This creates a type alias ID that can be either String or Int, using a custom Either enum to handle the union type.
typealias ID = Either<String, Int>

enum Either<T, U> {
    case first(T)
    case second(U)
}

// Basic Interface: outlines the structure that an object should follow
// This interface defines Point with x and y properties, both of which are numbers. Any object implementing this interface must adhere to this structure.
interface Point {
  x: number;
  y: number;
}


// Interface for Function Type: defines the expected signature of a function
// SearchFunc is an interface for a function that takes two string parameters and returns a boolean. This can be useful for type-checking functions.
interface SearchFunc {
  (source: string, subString: string): boolean;
}


// Extending Interfaces: allows one interface to inherit properties from another
// Square extends Shape, adding a sideLength property. This allows for a clear and concise definition of related interfaces.
interface Shape {
  color: string;
}

interface Square extends Shape {
  sideLength: number;
}

// Protocol Definition
// This defines a Drawable protocol with a draw method that conforming types must implement.
protocol Drawable {
    func draw()
}


// Struct Conforming to Protocol
// This Point struct conforms to the Drawable protocol, implementing the draw method.
struct Point: Drawable {
    var x: Int
    var y: Int

    func draw() {
        print("Drawing point at (\(x), \(y))")
    }
}

// Basic Class
// This Point class includes properties x and y and a move method to change the point's position.
class Point {
  x: number;
  y: number;

  constructor(x: number, y: number) {
    this.x = x;
    this.y = y;
  }

  move(dx: number, dy: number): void {
    this.x += dx;
    this.y += dy;
  }
}


// Class Inheritance
// Dog extends Animal, overriding the makeSound method to provide a specific implementation.
class Animal {
  name: string;

  constructor(name: string) {
    this.name = name;
  }

  makeSound(): void {
    console.log("Some generic sound");
  }
}

class Dog extends Animal {
  makeSound(): void {
    console.log("Bark");
  }
}


// Class Implementing Interface
// The Square class implements the draw method as required by the Drawable interface, ensuring it adheres to the contract.
interface Drawable {
  draw(): void;
}

class Square implements Drawable {
  draw() {
    console.log("Drawing a square");
  }
}

// Basic Class
// This Point class has properties x and y and a move method to update the point's position.
class Point {
    var x: Int
    var y: Int

    init(x: Int, y: Int) {
        self.x = x
        self.y = y
    }

    func move(dx: Int, dy: Int) {
        self.x += dx
        self.y += dy
    }
}


// Class Inheritance
// The Dog class extends Animal, overriding the makeSound method.
class Animal {
    var name: String

    init(name: String) {
        self.name = name
    }

    func makeSound() {
        print("Some generic sound")
    }
}

class Dog: Animal {
    override func makeSound() {
        print("Bark")
    }
}


// Class Conforming to Protocol
// The Circle class conforms to the Drawable protocol, implementing the draw method.
protocol Drawable {
    func draw()
}

class Circle: Drawable {
    var radius: Double

    init(radius: Double) {
        self.radius = radius
    }

    func draw() {
        print("Drawing a circle with radius \(radius)")
    }
}