TypeScript Phantom Types: Compile-Time Type Markers for Enhanced Safety

            
// Define currency type aliases using a phantom type parameter
type USD = number & { readonly __brand: unique symbol };
type EUR = number & { readonly __brand: unique symbol };

// Helper functions to create currency values
function USD(amount: number): USD {
  return amount as USD;
}

function EUR(amount: number): EUR {
  return amount as EUR;
}

// Example usage
const usdAmount = USD(100); // USD
const eurAmount = EUR(85); // EUR

// Valid operation: Adding USD to USD
const totalUSD = USD(USD(50) + USD(50));

// The following line will cause a type error at compile time:
// const total = usdAmount + eurAmount; // Error: Operator '+' cannot be applied to types 'USD' and 'EUR'.

console.log(`USD Amount: ${usdAmount}`);
console.log(`EUR Amount: ${eurAmount}`);
console.log(`Total USD: ${totalUSD}`);

            

              
                Copy
              
            
          

            
// Define phantom types representing different wizard states
type Step1 = { readonly __brand: unique symbol };
type Step2 = { readonly __brand: unique symbol };
type Completed = { readonly __brand: unique symbol };

// Define a Wizard class
class Wizard<T> {
  private state: T;

  constructor(state: T) {
    this.state = state;
  }

  static start(): Wizard<Step1> {
    return new Wizard<Step1>({} as Step1);
  }

  next(data: any): Wizard<Step2> {
    // Perform validation specific to Step 1
    console.log("Validating data for Step 1...");
    return new Wizard<Step2>({} as Step2);
  }

  finalize(data: any): Wizard<Completed> {
      // Perform validation specific to Step 2
      console.log("Validating data for Step 2...");
      return new Wizard<Completed>({} as Completed);
  }

  // Method only available when the wizard is completed
  getResult(this: Wizard<Completed>): any {
    console.log("Generating final result...");
    return { success: true };
  }
}

// Usage
let wizard = Wizard.start();
wizard = wizard.next({ name: "John Doe" });
wizard = wizard.finalize({ email: "john.doe@example.com" });
const result = wizard.getResult(); // Only allowed in the Completed state

// The following line will cause a type error because 'next' is not available after completion
// wizard.next({ address: "123 Main St" }); // Error: Property 'next' does not exist on type 'Wizard'.

console.log("Result:", result);

            

              
                Copy
              
            
          

            
// Define phantom types representing different validation states
type Unvalidated = { readonly __brand: unique symbol };
type Validated = { readonly __brand: unique symbol };

// Define a StringValue class
class StringValue<T> {
  private value: string;
  private state: T;

  constructor(value: string, state: T) {
    this.value = value;
    this.state = state;
  }

  static create(value: string): StringValue<Unvalidated> {
    return new StringValue<Unvalidated>(value, {} as Unvalidated);
  }

  validate(): StringValue<Validated> {
    // Perform validation logic (e.g., check for malicious characters)
    console.log("Validating string...");
    const isValid = this.value.length > 0; // Example validation
    if (!isValid) {
      throw new Error("Invalid string value");
    }
    return new StringValue<Validated>(this.value, {} as Validated);
  }

  getValue(this: StringValue<Validated>): string {
    // Only allow access to the value if it has been validated
    console.log("Accessing validated string value...");
    return this.value;
  }
}

// Usage
let unvalidatedString = StringValue.create("Hello, world!");
let validatedString = unvalidatedString.validate();
const value = validatedString.getValue(); // Only allowed after validation

// The following line will cause a type error because 'getValue' is not available before validation
// unvalidatedString.getValue(); // Error: Property 'getValue' does not exist on type 'StringValue'.

console.log("Value:", value);

            

              
                Copy
              
            
          

            
// Define phantom types representing different resource states
type Acquired = { readonly __brand: unique symbol };
type Released = { readonly __brand: unique symbol };

// Define a Resource class
class Resource<T> {
  private resource: any; // Replace 'any' with the actual resource type
  private state: T;

  constructor(resource: any, state: T) {
    this.resource = resource;
    this.state = state;
  }

  static acquire(): Resource<Acquired> {
    // Acquire the resource (e.g., open a database connection)
    console.log("Acquiring resource...");
    const resource = { /* ... */ }; // Replace with actual resource acquisition logic
    return new Resource<Acquired>(resource, {} as Acquired);
  }

  release(): Resource<Released> {
    // Release the resource (e.g., close the database connection)
    console.log("Releasing resource...");
    // Perform resource release logic (e.g., close connection)
    return new Resource<Released>(null, {} as Released);
  }

  use(this: Resource<Acquired>, callback: (resource: any) => void): void {
    // Only allow using the resource if it has been acquired
    console.log("Using acquired resource...");
    callback(this.resource);
  }
}

// Usage
let resource = Resource.acquire();
resource.use(r => {
  // Use the resource
  console.log("Processing data with resource...");
});
resource = resource.release();

// The following line will cause a type error because 'use' is not available after release
// resource.use(r => { }); // Error: Property 'use' does not exist on type 'Resource'.

            

              
                Copy
              
            
          

            
// Phantom types to represent API versions
type APIVersion1 = { readonly __brand: unique symbol };
type APIVersion2 = { readonly __brand: unique symbol };

// API client with versioning using phantom types
class APIClient<Version> {
  private version: Version;

  constructor(version: Version) {
    this.version = version;
  }

  static useVersion1(): APIClient<APIVersion1> {
    return new APIClient({} as APIVersion1);
  }

  static useVersion2(): APIClient<APIVersion2> {
    return new APIClient({} as APIVersion2);
  }

  getData(this: APIClient<APIVersion1>): string {
    console.log("Fetching data using API Version 1");
    return "Data from API Version 1";
  }

  getUpdatedData(this: APIClient<APIVersion2>): string {
    console.log("Fetching data using API Version 2");
    return "Data from API Version 2";
  }
}

// Usage example
const apiClientV1 = APIClient.useVersion1();
const dataV1 = apiClientV1.getData();
console.log(dataV1);

const apiClientV2 = APIClient.useVersion2();
const dataV2 = apiClientV2.getUpdatedData();
console.log(dataV2);

// Attempting to call Version 2 endpoint on Version 1 client results in a compile-time error
// apiClientV1.getUpdatedData(); // Error: Property 'getUpdatedData' does not exist on type 'APIClient'.

            

              
                Copy