Photo by Kelly Sikkema on Unsplash

Functional Programming Concepts

Functional programming is a powerful paradigm that emphasizes writing code in a declarative and expressive manner. In this approach, functions play a central role, and immutable data is preferred. Instead of using traditional object-oriented techniques, functional programming offers a different way of thinking about software design. In recent years, functional programming has gained popularity among developers, and Kotlin, as a versatile language, embraces functional programming concepts.

By adopting functional programming in Kotlin, developers can unlock several benefits that enhance code quality and maintainability:

1. Clarity: Functional programming promotes self-contained and composable functions, making code easier to understand and reason about.
2. Conciseness: With features like lambdas and higher-order functions, Kotlin allows you to express complex operations in a compact and intuitive way.
3. Avoiding Side Effects: Functional programming reduces side effects by emphasizing immutability and pure functions, leading to more predictable code.
4. Testability: Functional code tends to be more testable, as it relies on clear inputs and outputs without hidden state changes.
5. Parallelism and Concurrency: Functional programming’s focus on immutability and lack of shared state enables better parallel execution for potential performance gains.

Kotlin provides robust support for functional programming, making it a natural fit for incorporating these principles into your Android projects. If you want to explore functional programming in Kotlin further and learn how to apply it effectively in clean architecture, I highly recommend reading the insightful blog post “How to Leverage Functional Programming in Kotlin to Write Better, Cleaner Code” from DoorDash Engineering.

Reference Link: How to Leverage Functional Programming in Kotlin to Write Better, Cleaner Code

Refined Approach: Moving to the UseCase Layer

Before starting, I recommend you to check the first article of this story to understand why we are in our current situation.

Building upon our previous efforts to consolidate method calls within the getUserData() and getAdminData() functions, we have achieved notable improvements in the readability and maintainability of our codebase. However, we can elevate our solution further by transitioning these methods to the UseCase layer before we explore more about functional programming. This strategic move will not only enhance code clarity but also refine the implementation of our clean architecture.

By relocating the public methods to the UseCase layer, they now act as concise summaries of the specific functionality provided by each use case. Rather than merely serving as invokers of repository methods, the UseCase layer now encapsulates the core logic of the application, acting as a central hub for understanding business rules and interactions.

The role of the Repository becomes more refined in this approach. Instead of hosting the core business logic, the Repository focuses solely on providing the right data sources for the UseCase. This promotes a clearer separation of concerns, making it easier to understand the purpose and responsibilities of each component in our architecture.

Let’s update our code accordingly:

class GetUserDataUseCase(private val userRepository: UserRepository) {

    operator fun invoke(): Result<UserData, String> {
        val isSupported = userRepository.checkIfSupported()
        if (!isSupported) {
            return Result.failure("User not supported by the system.")
        }
        // Consolidated method calls within the UseCase layer.
        val userData = userRepository.fetchUserDataFromAPI()
        val processedData = userRepository.processData(userData)
        val userType = userRepository.checkType(processedData)
        // More user-specific logic here...
        // ...
        return Result.success(processedData)
    }
}

class GetAdminDataUseCase(private val userRepository: UserRepository) {
    operator fun invoke(): Result<UserData, String> {
        val isSupported = userRepository.checkIfSupported()
        if (!isSupported) {
            return Result.failure("User not supported by the system.")
        }
        // Calling checkDeviceAvailability only for admin data retrieval.
        val userData = userRepository.fetchUserDataFromAPI()
        val processedData = userRepository.processData(userData)
        val userType = userRepository.checkType(processedData)
        val isConnected = userRepository.connectToDevice()
        val isDeviceAvailable = userRepository.checkDeviceAvailability()
        // More admin-specific logic here...
        // ...
        return Result.success(processedData)
    }
}

Advantages of the Approach

1. Improved Readability: Moving the public methods to the UseCase layer results in a clearer and more expressive codebase. Each UseCase class acts as a high-level summary of its purpose, making it easy for developers to understand the operations.
2. Better Code Organization: The UseCase layer becomes a central point for business logic, streamlining code maintenance and navigation. This approach allows us to focus on specific functionality within each use case without being overwhelmed by private methods.
3. Easier Testing: With the UseCase layer encapsulating core business logic, testing becomes more straightforward. Writing targeted tests for each use case promotes better test coverage and boosts confidence in the application’s behavior.
4. Clear Role of Repository: The UseCase layer takes charge of orchestrating business logic, refining the role of the Repository. Now, the Repository solely focuses on providing the right data sources for the UseCase, leading to a clearer separation of concerns.

Leveraging Kotlin’s Function-First Approach in the UseCase Layer

In Kotlin, we have the flexibility to create functions directly without the need to define a class first. This feature allows us to take advantage of a more functional programming style in the UseCase layer. Instead of creating separate classes for each UseCase, we can define functions that represent individual use cases, making our code more concise and expressive.

Let’s demonstrate this approach using the previous code as an example:

// Separate functions for getUserData and getAdminData UseCases
fun getUserDataUseCase(
    userRepository: UserRepository
): (Result<UserData, String>) {
    return {
        val isSupported = userRepository.checkIfSupported()
        if (!isSupported) {
            Result.failure("User not supported by the system.")
        } else {
            // Consolidated method calls inside the getUserDataUseCase.
            val userData = userRepository.fetchUserDataFromAPI()
            val processedData = userRepository.processData(userData)
            val userType = userRepository.checkType(processedData)
            // More user-specific logic here...
            // ...
            Result.success(processedData)
        }
    }
}

fun getAdminDataUseCase(
    userRepository: UserRepository
): (Result<UserData, String>) {
    return {
        val isSupported = userRepository.checkIfSupported()
        if (!isSupported) {
            Result.failure("User not supported by the system.")
        } else {
            // Calling checkDeviceAvailability only for admin data retrieval.
            val userData = userRepository.fetchUserDataFromAPI()
            val processedData = userRepository.processData(userData)
            val userType = userRepository.checkType(processedData)
            val isConnected = userRepository.connectToDevice()
            val isDeviceAvailable = userRepository.checkDeviceAvailability()
            // More admin-specific logic here...
            // ...
            Result.success(processedData)
        }
    }
}

Advantages of Using Function-First Approach:

1. Concise and Expressive: By using functions directly in the UseCase layer, our code becomes more compact and expressive. We avoid the need to define separate classes for each UseCase, reducing boilerplate code and making the codebase easier to understand.
2. Enhanced Flexibility: Functions provide greater flexibility in defining and composing behavior. We can create higher-order functions or combine functions with other functional programming concepts to create more powerful and reusable code.
3. Improved Separation of Concerns: With function-first design, each UseCase is encapsulated as a function, promoting a clearer separation of concerns. The UseCase layer focuses solely on business logic, while the Repository layer handles data retrieval and storage.

Taking Function Composition to the Next Level

In Kotlin, we can further enhance the functional programming style by leveraging its support for first-class functions. By treating functions as first-class citizens, we can assign them to variables and create higher-order functions. This approach not only simplifies our code but also enables us to compose functions more effectively, making our code more modular and reusable.

Let’s illustrate this concept with the previous code:

typealias UseCase<T, R> = (T) -> R

// Separate functions for getUserData and getAdminData UseCases
val getUserDataUseCase: 
        UseCase<UserRepository, Result> = { userRepository ->
    val isSupported = userRepository.checkIfSupported()
    if (!isSupported) {
        Result.failure("User not supported by the system.")
    } else {
        // Consolidated method calls inside the getUserDataUseCase function.
        val userData = userRepository.fetchUserDataFromAPI()
        val processedData = userRepository.processData(userData)
        val userType = userRepository.checkType(processedData)
        // More user-specific logic here...
        // ...
        Result.success(processedData)
    }
}
val getAdminDataUseCase: 
      UseCase<UserRepository, Result> = { userRepository ->
    val isSupported = userRepository.checkIfSupported()
    if (!isSupported) {
        Result.failure("User not supported by the system.")
    } else {
        val userData = userRepository.fetchUserDataFromAPI()
        val processedData = userRepository.processData(userData)
        val userType = userRepository.checkType(processedData)
        val isConnected = userRepository.connectToDevice()
        // Calling checkDeviceAvailability only for admin data retrieval.
        val isDeviceAvailable = userRepository.checkDeviceAvailability()
        // More admin-specific logic here...
        // ...
        Result.success(processedData)
    }
}

Advantages of Function Composition:

1. Simplified and Modular Code: By using first-class functions and typealias, our code becomes more streamlined and modular. Each UseCase is now defined as a variable, which promotes code reusability and easier maintenance.
2. Composable Design: Functions can be easily combined and composed, enabling us to create higher-order functions that encapsulate common behavior. This composable design allows us to build complex operations by chaining smaller, reusable functions.
3. Readability and Expressiveness: The use of typealias and first-class functions makes the code more readable and expressive. We can understand the purpose and behavior of each UseCase without having to navigate through multiple classes.

By embracing the power of function composition, we unlock a new level of flexibility and expressiveness in our functional programming style. This approach allows us to create more concise, maintainable, and reusable code, making it easier to adapt and scale our application. With Kotlin’s support for first-class functions, we can build a more cohesive and enjoyable development experience for our clean architecture projects.

Refined Approach: Streamlining Code with Higher-Order Functions

As we continue to enhance our Clean Architecture implementation, we can further optimize our codebase by introducing a generic higher-order function. This function will encapsulate the common behavior of checking if the user is supported, reducing duplication and promoting code reusability.

Let’s take a look at the updated code with the generic higher-order function:

typealias UseCase<T, R> = (T) -> Result<R, String>

// Generic higher-order function for common behavior
fun <T, R> supportedCheckUseCase(useCase: UseCase<T, R>): UseCase<T, R> {
    return { input ->
        val isSupported = input.checkIfSupported()
        if (!isSupported) {
            Result.failure("User not supported by the system.")
        } else {
            useCase(input)
        }
    }
}

// Separate functions for getUserData and getAdminData UseCases
val getUserDataUseCase: UseCase<UserRepository, UserData> =
    supportedCheckUseCase { userRepository ->
        val userData = userRepository.fetchUserDataFromAPI()
        val processedData = userRepository.processData(userData)
        val userType = userRepository.checkType(processedData)

        // More user-specific logic here...
        // ...

        Result.success(processedData)
    }

val getAdminDataUseCase: UseCase<UserRepository, UserData> =
    supportedCheckUseCase { userRepository ->
        val userData = userRepository.fetchUserDataFromAPI()
        val processedData = userRepository.processData(userData)
        val userType = userRepository.checkType(processedData)
        val isConnected = userRepository.connectToDevice()
        val isDeviceAvailable = userRepository.checkDeviceAvailability()

        // More admin-specific logic here...
        // ...

        Result.success(processedData)
    }

typealias UseCase<T, R> = (T) -> Result<R, String>

// The magic higher-order function for common behavior
fun <T, R> supportedCheckUseCase(useCase: UseCase<T, R>): UseCase<T, R> {
    return { input ->
        val isSupported = input.checkIfSupported()
        if (!isSupported) {
            Result.failure("User not supported by the system.")
        } else {
            useCase(input)
        }
    }
}

// Our awesome UseCases with fluent interfaces
val getUserDataUseCase: UseCase<UserRepository, UserData> =
    supportedCheckUseCase { userRepository ->
        userRepository.fetchUserDataFromAPI()
            .processData()
            .checkType()
            .result()
    }

val getAdminDataUseCase: UseCase<UserRepository, UserData> =
    supportedCheckUseCase { userRepository ->
        userRepository.fetchUserDataFromAPI()
            .processData()
            .checkType()
            .connectToDevice()
            .checkDeviceAvailability()
            .result()
    }

class UserRepository {
    // Other methods and properties...
    
    // Extension functions for the fluent interface pattern
    fun fetchUserDataFromAPI(): UserData {
        // Code to fetch user data from API...
    }

    fun UserData.processData(): ProcessedData {
        // Code to process user data...
    }

    fun ProcessedData.checkType(): UserType {
        // Code to check the type of user data...
    }

    fun UserType.connectToDevice(): DeviceConnectionStatus {
        // Code to check device connection...
    }

    fun DeviceConnectionStatus.checkDeviceAvailability(
    ): DeviceAvailabilityStatus {
        // Code to check if the device is available...
    }

    fun DeviceAvailabilityStatus.result(): Result<UserData, String> {
        // Code to wrap the result...
    }
}

This article was previously published on proandrdoiddev.com