> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Kotlin Infix Function
An infix function in Kotlin is a member or extension function marked with the `infix` modifier, enabling it to be invoked using infix notation. This notation omits the dot (`.`) receiver call and the parentheses `()` around the argument, placing the function identifier directly between the receiver and the argument.
## Technical Requirements
The Kotlin compiler enforces strict structural rules for a function to qualify for the `infix` modifier. The function must:
1. **Scope:** Be declared as either a member function or an extension function.
2. **Arity:** Declare exactly one value parameter.
3. **Parameter Constraints:** The single parameter must not accept a variable number of arguments (`vararg`) and must not declare a default value.
## Syntax and Declaration
To define an infix function, prepend the `infix` keyword to the `fun` declaration.
```kotlin theme={"dark"}
// Extension infix function
infix fun String.append(other: String): String {
return this + other
}
class Container(val count: Int) {
// Member infix function
infix fun combine(other: Container): Container {
return Container(this.count + other.count)
}
}
```
## Invocation Mechanics
When invoking an infix function, the compiler translates the infix syntax into a standard method dispatch.
```kotlin theme={"dark"}
val strResult = "System" append "Failure"
// Compiler translates to: "System".append("Failure")
val containerA = Container(5)
val containerB = Container(10)
val combined = containerA combine containerB
// Compiler translates to: containerA.combine(containerB)
```
**Implicit Receivers:**
If an infix function is called on the current class instance (`this`), the receiver cannot be implicit when using infix notation. The `this` keyword must be explicitly stated.
```kotlin theme={"dark"}
class Processor {
infix fun process(data: String) { /*...*/ }
fun execute() {
this process "Payload" // Valid
process("Payload") // Valid (Standard invocation)
// process "Payload" // Compilation Error: Receiver required
}
}
```
## Operator Precedence
Infix function calls occupy a specific tier in Kotlin's operator precedence hierarchy. They possess:
* **Lower precedence** than arithmetic operators, type casts, and the `rangeTo` operator.
```kotlin theme={"dark"}
```
// 'shl' (shift left) is a standard library infix function
val result = 1 shl 2 + 3
// Evaluates as: 1 shl (2 + 3) -> 1 shl 5
````
* **Higher precedence** than boolean operators (`&&`, `||`), `is` and `in` checks, and other logic operators.
```kotlin
// 'xor' is a standard library infix function
val flag = true && false xor true
// Evaluates as: true && (false xor true)
````
* **Left-associativity** when chaining multiple infix functions of the same precedence.
```kotlin theme={"dark"}
```
val chain = "A" append "B" append "C"
// Evaluates as: ("A" append "B") append "C"
```
Tired of Poor Kotlin Skills? Fix That With Deep Grasping!
Learn More
```
