Should function arguments be reassignable or mutable?
Tags: programming, coding, language
Published: 2017-12-31 08:33:25

---
title: Should function arguments be reassignable or mutable?
published: true
description: A discussion of the correct semantics for function arguments?
tags: programming, coding, language
canonical_url: https://mortoray.com/2017/12/31/should-function-arguments-be-reassignable-or-mutable/
cover_image: https://mortoray.files.wordpress.com/2017/12/pattern-background-1245991_640.jpg
---
 

Working on a defect in [Leaf](http://leaflang.org) I had a question: should function arguments be reassignable within a function? Are they just like local variables, or should they be treated specially? It would solve my problem in the Leaf compiler, but I don't like making decisions for technical convenience. What is the correct answer?

> This is an open question and I'd love to hear your feedback. The article is details and my viewpoint, but I don't reach a conclusion.


## Imperative approach

In the languages rooted in [imperative programming](https://mortoray.com/2017/05/10/what-is-imperative-programming/), like C, C++, Java, and C#, we can freely use function arguments as local variables.

```cpp
int calc( int a, int b ) {
    a += b
    b += a
    return a
}
```

I admit that I often write code that does this. It's convenient to reuse an existing variable rather than introducing a new one. I realize it's also gotten me into trouble before. When a piece of code modifies the arguments, but code later in the function wasn't expecting that.

```cpp
int calc( float a, int b ) {
    float result = a;
    
    if (some_conditon_on(a)) {
        b /= 5;
        result += b;
    }
    
    if (some_condition_on(b)) {
        result = alt_calc(a,b);
    }
    
    return result;
}
```

Though contrived, it shows that a second section of the code in the function may be relying on unmodified arguments. It's a subtle defect as it requires both conditionals to evaluate to true. Add in more branches that may or may not modify the arguments, and the problem intensifies.

In JavaScript, that situation is worse. If I modify a named argument, it also modifies the `arguments` array.

```javascript
function hidden_arg( name ) {
    name = "weird"
    console.log(arguments[0])
}


hidden_arg("expected")
```

That writes `weird`, not `expected`.


## Functional approach

If we look to a language like Haskell we see that reassigning variables, in general, is frowned upon (is it even possible?). It's not something fundamental to a [functional programming](https://mortoray.com/2017/05/25/what-is-functional-programming/) though, whether a function a reassigns an argument doesn't affect the purity of that function.

A function could, however, modify the value of an argument, and that would certainly ruin the immutable requirement.

This got me to thinking that perhaps the requirement should go even further: arguments should also be read-only by default. Consider the below code, where the "values" name is not reassignable (C and C++ are of the few languages where this notation is even possible):

```cpp
//this prevents reassigning the "values" pointer...
float calc( vector<float> * const values ) {
    values[0] = 1; //...but we can still modify the values
    ...
}
```

What if the default were also to make everything read-only? _(This is the typical C++ syntax for how that is done)_

```cpp
float calc( vector<float> const & values ) {
    values[0] = 1; //error!
    ...
}
```

This function has a much safer signature. I can call it without worrying that my vector might be accidentally changed on me.

> I guess it's unavoidable for this discussion to get deeper into the [difference between a name of a value](https://mortoray.com/2013/01/18/divorcing-a-value-from-its-name/).


## The default, but not a hard requirement

I'm starting to think that non-reassignable and read-only should be the default. If I want a mutable argument, I can mark it.

```cpp
float sort( vector<float> mutable & values )
```

For complex value types that makes a lot of sense. But for service types, like say a file or window handle, it would be inconvenient. At least in Leaf, I have a distinct `service` type, which could be mutable by default instead. I don't like inconsistency, but sometimes it has to be sacrificed for convenience.

Another situation that gives me pause is argument sanitization. For example:

```cpp
float calc( float a, float b ) {
    if (b < 0) {
        a = -a;
        b = -b;
    }
    
    ...
}
```

In this situation, we don't want the remainder of the function to have access to the original arguments. They're intentionally hidden. Cleaning arguments may not be common, but I do it often enough that I'd need to have a solution for it. Perhaps hiding the arguments by a local variable of the same name might work.


## Your thoughts?

I'm undecided on what the correct solution is. Current languages and best practices don't appear to give a definite answer yet. This makes it one of those engaging topics in language design.

It's part of my adventure in writing Leaf. I'd be happy to hear your thoughts on the topic as well.