---
layout: ../../../layouts/DocsLayout.astro
title: Function parameters
---
import Code from "../../../components/Code.astro"

# Function parameters


## Immutable reference

<Code thpcode={`
fun add_25(Array[Int] numbers) {
    numbers.push(25)    // Error: \`numbers\` is immutable
}
`} />

When using a regular type as a parameter, only it's immutable
properties can be used

<Code thpcode={`
fun count(Array[Int] numbers) -> Int {
    val items_count = numbers.size()    // Ok, \`size\` is pure

    items_count
}
`} />

To use immutable properties you must use a mutable reference.


## Mutable reference

<Code thpcode={`
fun push_25(mut Array[Int] numbers) {
    numbers.push(25)    // Ok, will also mutate the original array
}
`} />

Placing a `mut` before the type makes the parameter a mutable
reference. Mutable methods can be used, and the original
data **can** be mutated.

The caller *must* also use `mut`.

<Code thpcode={`
val numbers = Array(0, 1, 2, 3)

push_25(mut numbers)    // Pass \`numbers\` as reference.

print(numbers(4))   // \`Some(25)\`
`} />



## Clone

<Code thpcode={`
fun add_25(clone Array[Int] numbers) {
    numbers.push(25)    // Ok, the original array is unaffected
}
`} />

Using the `clone` keyword before the type creates a mutable copy
of the parameter (CoW). The original data will **not** be mutated.


<Code thpcode={`
val numbers = Array(1, 2, 3, 4)

add_25(clone numbers)    // Pass \`numbers\` as clone.

print(numbers(4))   // None
`} />


