## Kotlin Classes, Objects, Constructors and Initializers

Kotlin supports method calls of a special kind, called *infix calls*.

You can mark any member function or extension function with the *infix* modifier to allow it to be called using infix notation. The only requirement is that the function should have only one required parameter.

Infix notations are used extensively in Kotlin. If you’ve been programming in Kotlin, chances are that you’ve already used infix notations.

Following are few common examples of infix notations in Kotlin –

**1. Infix Notation Example – Creating a Map**

```
val map = mapOf(1 to "one", 2 to "two", 3 to "three")
```

In the above example, the expressions `1 to "one"`

, `2 to "two"`

etc, are infix notations of the function calls `1.to("one")`

and `2.to("two")`

etc.

`to()`

is an infix function that creates a `Pair<A, B>`

from two values.

**2. Infix Notation Example – Range Operators (until, downTo, step)**

Kotlin provides various range operators that are usually called using infix notation –

```
for(i in 1 until 10) { // Same as - for(i in 1.until(10))
print("$i ")
}
```

```
for(i in 10 downTo 1) { // Same as - for(i in 10.downTo(1))
print("$i ")
}
```

```
for(i in 1 until 10 step 2) { // Same as - for(i in 1.until(10).step(2))
print("$i ")
}
```

**3. Infix Notation Example – String.matches()**

The `String.matches()`

function in Kotlin which matches a `String`

with a `Regex`

is an infix function –

```
val regex = Regex("[tT]rue|[yY]es")
val str = "yes"
str.matches(regex)
// Infix notation of the above function call -
str matches regex
```

### Creating an Infix Function

You can make a single argument member function or extension function, an infix function by marking it with the `infix`

keyword.

Check out the following example where I have created an infix member function called `add()`

for adding two Complex numbers –

```
data class ComplexNumber(val realPart: Double, val imaginaryPart: Double) {
// Infix function for adding two complex numbers
infix fun add(c: ComplexNumber): ComplexNumber {
return ComplexNumber(realPart + c.realPart, imaginaryPart + c.imaginaryPart)
}
}
```

You can now call the `add()`

method using infix notation –

```
val c1 = ComplexNumber(3.0, 5.0)
val c2 = ComplexNumber(4.0, 7.0)
// Usual call
c1.add(c2) // produces - ComplexNumber(realPart=7.0, imaginaryPart=12.0)
// Infix call
c1 add c2 // produces - ComplexNumber(realPart=7.0, imaginaryPart=12.0)
```

## Conclusion

That’s all folks. In this article, You learned what infix notation is and how it works. You saw several examples of Infix notations in Kotlin and also learned how to create an infix function.