Type Aliases in Kotlin

// Simple type alias
typealias Username = String

// Function type alias
typealias ValidationRule<T> = (T) -> Boolean

// Generic type alias
typealias Dictionary<K, V> = Map<K, V>

// Without type alias
val handlers: MutableMap<String, (List<String>, Map<String, Any>) -> Unit> = mutableMapOf()

// With type aliases
typealias EventData = Map<String, Any>
typealias EventHandler = (List<String>, EventData) -> Unit

// Much clearer
val handlers: MutableMap<String, EventHandler> = mutableMapOf()

// Complex callback type
typealias DataCallback<T> = (data: T?, error: Exception?) -> Unit

class DataRepository {
    fun fetchData(callback: DataCallback<User>) {
        try {
            val user = // fetch user
            callback(user, null)
        } catch (e: Exception) {
            callback(null, e)
        }
    }
}

typealias EmailAddress = String
typealias PhoneNumber = String
typealias UserId = Long

data class User(
    val id: UserId,
    val email: EmailAddress,
    val phone: PhoneNumber
)

// Type-safe function parameters
fun sendEmail(to: EmailAddress, subject: String, body: String) {
    // Send email implementation
}

// Generic type alias for API responses
typealias ApiResponse<T> = Result<Pair<T, Int>>

class ApiClient {
    fun <T> makeRequest(endpoint: String): ApiResponse<T> {
        return try {
            // Make API call
            val (data, statusCode) = // process response
            Result.success(data to statusCode)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
}

typealias Graph<T> = Map<T, Set<T>>
typealias Matrix = Array<Array<Double>>
typealias JSONObject = Map<String, Any?>

// Usage
class GraphProcessor<T> {
    fun findPath(graph: Graph<T>, start: T, end: T): List<T> {
        // Path finding implementation
    }
}

typealias Transformer<T> = (T) -> T
typealias Predicate<T> = (T) -> Boolean

class Pipeline<T> {
    private val transformers = mutableListOf<Transformer<T>>()
    
    fun addTransformer(transformer: Transformer<T>) {
        transformers.add(transformer)
    }
    
    fun process(input: T): T {
        return transformers.fold(input) { acc, transformer -> 
            transformer(acc)
        }
    }
}

// Good - Clear and descriptive
typealias HttpHeaders = Map<String, List<String>>
typealias RequestHandler = (HttpRequest) -> HttpResponse

// Bad - Too vague
typealias Data = Map<String, Any>
typealias Process = (Any) -> Any

/**
 * Represents a validation function that takes an input of type T
 * and returns a ValidationResult containing potential errors.
 */
typealias Validator<T> = (input: T) -> ValidationResult

/**
 * Represents the result of a validation operation.
 * Contains a list of validation errors, if any.
 */
data class ValidationResult(
    val errors: List<String> = emptyList()
) {
    val isValid: Boolean get() = errors.isEmpty()
}

// Module-level type alias
private typealias InternalCache = MutableMap<String, Any>

class CacheManager {
    // Class-specific type alias
    private typealias CacheEntry = Pair<Any, Long>
    
    private val cache = mutableMapOf<String, CacheEntry>()
}

typealias EventListener<T> = (T) -> Unit
typealias EventSubscription = () -> Unit

class EventEmitter<T> {
    private val listeners = mutableListOf<EventListener<T>>()
    
    fun emit(event: T) {
        listeners.forEach { it(event) }
    }
    
    fun subscribe(listener: EventListener<T>): EventSubscription {
        listeners.add(listener)
        return { listeners.remove(listener) }
    }
}

typealias ServiceFactory<T> = () -> T
typealias ServiceProvider<T> = () -> T?

class ServiceLocator {
    private val factories = mutableMapOf<Class<*>, ServiceFactory<*>>()
    
    fun <T : Any> register(clazz: Class<T>, factory: ServiceFactory<T>) {
        factories[clazz] = factory
    }
    
    fun <T : Any> get(clazz: Class<T>): T {
        @Suppress("UNCHECKED_CAST")
        return (factories[clazz] as? ServiceFactory<T>)?.invoke()
            ?: throw IllegalArgumentException("No factory registered for ${clazz.name}")
    }
}

typealias StateReducer<S, A> = (state: S, action: A) -> S
typealias StateListener<S> = (state: S) -> Unit

class Store<S, A>(
    initialState: S,
    private val reducer: StateReducer<S, A>
) {
    private var state: S = initialState
    private val listeners = mutableListOf<StateListener<S>>()
    
    fun dispatch(action: A) {
        state = reducer(state, action)
        listeners.forEach { it(state) }
    }
    
    fun subscribe(listener: StateListener<S>) {
        listeners.add(listener)
    }
}

// Using type aliases for stronger type safety
typealias Meters = Double
typealias Kilometers = Double

class DistanceCalculator {
    fun metersToKilometers(meters: Meters): Kilometers {
        return meters / 1000.0
    }
}

// Before
fun process(
    data: List<Pair<String, Map<String, List<Int>>>>,
    handler: (Pair<String, Map<String, List<Int>>>) -> Unit
) {
    // Implementation
}

// After
typealias DataEntry = Pair<String, Map<String, List<Int>>>
typealias DataProcessor = (DataEntry) -> Unit

fun process(data: List<DataEntry>, handler: DataProcessor) {
    // Implementation
}