Type Inference

dtsx provides powerful type inference capabilities to automatically determine types from your code.

Basic Type Inference

Literal Types

// String literal
const name = "John";  // type: "John"

// Number literal
const age = 25;       // type: 25

// Boolean literal
const isActive = true; // type: true

Array Types

// Array of numbers
const numbers = [1, 2, 3];  // type: number[]

// Tuple type
const tuple = [1, "hello"]; // type: [number, string]

Object Types

const user = {
  name: "John",
  age: 25,
  active: true
}; // type: { name: string; age: number; active: boolean; }

Advanced Type Inference

Function Return Types

function process<T>(input: T) {
  return input;
} // Return type: T

async function fetchData() {
  return await api.get('/data');
} // Return type: Promise<ApiResponse>

Generic Type Inference

function map<T, U>(arr: T[], fn: (item: T) => U): U[] {
  return arr.map(fn);
}

// Usage
const numbers = [1, 2, 3];
const strings = map(numbers, n => n.toString());
// strings type: string[]

Union Type Inference

function processValue(value: string | number) {
  if (typeof value === 'string') {
    return value.toUpperCase(); // type: string
  }
  return value.toFixed(2); // type: string
}

Type Inference Features

Contextual Typing

• Function parameters
• Object literals
• Array literals
• Class members
• Interface implementations

Type Narrowing

• Type guards
• Control flow analysis
• Discriminated unions
• Property checks

Type Widening

• Literal to primitive
• Union type expansion
• Const assertions
• Type assertions

Best Practices

1. Use Type Annotations When Needed

   // When inference might be too specific
   const config: Config = {
     // ...
   };

2. Leverage Const Assertions

   const colors = ['red', 'green', 'blue'] as const;
   // type: readonly ["red", "green", "blue"]

3. Use Type Guards

   function isUser(value: unknown): value is User {
     return typeof value === 'object' && value !== null && 'name' in value;
   }

4. Avoid Type Assertions

   // Prefer this
   const value = process(input);
   
   // Over this
   const value = process(input) as string;

Configuration

interface TypeInferenceConfig {
  // Enable/disable type inference
  enableInference: boolean;

  // Inference strictness level
  strictness: 'loose' | 'strict' | 'very-strict';

  // Custom inference rules
  customRules: InferenceRule[];
}