alivirgo/major-ai-skills/type-alias-compression

┌─────────────────────────────────────────────────────────────┐
│                 Type Signature Token Density                │
│                                                             │
│  Repetitive Nested Generics (15 Methods / 420 Tokens):      │
│  export async function getUser(id: string):                 │
│    Promise<AxiosResponse<ApiResponse<PaginatedResult<User>>>>{...}│
│  export async function getOrg(id: string):                  │
│    Promise<AxiosResponse<ApiResponse<PaginatedResult<Org>>>>{...} │
│  ↳ 420 tokens billed purely repeating identical generic wraps│
│                                                             │
│  Compressed Type Alias (1 Definition / 65 Tokens):          │
│  type ApiPage<T> = Promise<AxiosResponse<ApiResponse<PaginatedResult<T>>>>;│
│  export async function getUser(id: string): ApiPage<User> {...}│
│  export async function getOrg(id: string): ApiPage<Org> {...} │
│  ↳ 65 clean tokens (84.5% Reduction!), single point of change│
└─────────────────────────────────────────────────────────────┘

// 1. Define High-Frequency Aliases at Top of File
export type AsyncResult<T> = Promise<{ data: T; error: null } | { data: null; error: string }>;
export type Handler<TReq, TRes> = (req: Request<TReq>, res: Response<TRes>) => Promise<void>;
export type ID = string | number;
// 2. Ultra-Clean Method Signatures
export async function fetchUser(id: ID): AsyncResult<User> { ... }
export async function updateProfile(id: ID, payload: UserDto): AsyncResult<User> { ... }

from typing import Callable, Coroutine, Any
# Python 3.12 native type statement
type JsonResult[T] = Coroutine[Any, Any, dict[str, T]]
type MiddlewareFn = Callable[[Request, Callable], Response]
async def get_user_profile(user_id: str) -> JsonResult[UserProfile]:
    ...

use std::result::Result as StdResult;
 
// Aliasing heavy error types across the crate
pub type Result<T> = StdResult<T, AppEngineError>;
pub type UserMap = std::collections::HashMap<String, UserProfile>;
 
pub fn get_user(id: &str) -> Result<UserProfile> { ... }