Kotlin中能否提取函数公共参数？寻求语言特性层面解决方案

Great question! Eliminating that repetitive common parameter boilerplate is totally doable using core Kotlin language features—no messy workarounds needed. Let’s break down approaches that align with what you’re looking for, including alternatives that mirror Scala’s implicit pattern.

First, here’s your original code for reference:

object Helper{
    fun getValuesForBlah1(constParam1 : Boolean, constParam2 : String, constParam3 : Float, varParam : Int) {}
    fun getValuesForBlah2(constParam1 : Boolean, constParam2 : String, constParam3 : Float, varParam : SomeClass) {}
    fun getValuesForBlah3(constParam1 : Boolean, constParam2 : String, constParam3 : Float, varParam : SomeOtherClass) {}
    // ... more functions
}

Approach 1: Data Class + Extension Functions (Intuitive & Widely Compatible) #

Wrap the shared parameters into a data class, then convert your helper functions into extensions on this class. This makes the common parameters implicitly available to each function:

// Step 1: Encapsulate common parameters in a reusable data class
data class BlahContext(
    val constParam1: Boolean,
    val constParam2: String,
    val constParam3: Float
)

// Step 2: Turn helper functions into extensions on BlahContext
fun BlahContext.getValuesForBlah1(varParam: Int) {
    // Access common params directly (or with `this.` for clarity)
    println("Using $constParam1, $constParam2, $constParam3 with variable param: $varParam")
}

fun BlahContext.getValuesForBlah2(varParam: SomeClass) {
    // Your business logic here
}

fun BlahContext.getValuesForBlah3(varParam: SomeOtherClass) {
    // Your business logic here
}

Usage:

// Initialize the common context once
val commonContext = BlahContext(true, "sample-text", 3.14f)

// Call functions without repeating common parameters
commonContext.getValuesForBlah1(42)
commonContext.getValuesForBlah2(SomeClass())

Approach 2: Context Receivers (Kotlin 1.6+, Similar to Scala's Implicit) #

If you want a pattern closer to Scala’s implicit—where the common context is available in a scope without explicit reference—use Kotlin’s context receivers. This lets you declare that your functions depend on a specific context, which you can inject into a code block:

// Reuse the BlahContext data class from Approach 1

// Declare functions with a context dependency
context(BlahContext)
fun getValuesForBlah1(varParam: Int) {
    // No need for `this`—common params are directly in scope!
    println("Using $constParam1, $constParam2, $constParam3 with variable param: $varParam")
}

context(BlahContext)
fun getValuesForBlah2(varParam: SomeClass) {
    // Your business logic here
}

Usage:

// Inject the context into a block using `run`, `with`, or `apply`
BlahContext(true, "sample-text", 3.14f).run {
    getValuesForBlah1(42)
    getValuesForBlah2(SomeClass())
    // All helper functions in this block automatically access the common context
}

This feels very similar to Scala’s implicit scope: you define the context once, and all functions in the block can use it without passing it explicitly.

Why These Work Better Than Ad-Hoc Fixes #

Both approaches use native Kotlin features to clean up your code:

• The data class approach is simple, compatible with all Kotlin versions, and keeps dependencies explicit.
• Context receivers offer a more "implicit-like" experience, keeping function signatures lean while still making dependencies clear via the context declaration.

Neither requires messy default parameters or global state—common pitfalls of less elegant workarounds.

内容的提问来源于stack exchange，提问作者Ashwin