Should function arguments be reassignable or mutable?

综合技术 2017-12-31

Working on a defect in Leaf
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
, like C, C++, Java, and C#, we can freely use function arguments as local variables.

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.

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.

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
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):

//this prevents reassigning the "values" pointer...
float calc( vector * 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)

float calc( vector 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
.

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.

float sort( vector 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:

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.

您可能感兴趣的

Python3函数式编程小结 Python函数式编程 函数式编程可以使代码更加简洁,易于理解。Python提供的常见函数式编程方法如下: map(函数,可迭代式) 映射函数 filter(函数,可迭代式) 过滤函数 reduce(函数,可...
C++ Core Guidelines: Declarations and Initialisati... Let's continue our tour through the rules for expressions and statements in the C++ core guidelines. This post will be about declarations and initiali...
Mouse Input Using C# In Unity Introduction This article demonstrates how to input through the mouse using C# scripts in Unity. Prerequisites Unity Environment version 5.6....
new vs operator new in C++ When you create a new object, memory is allocated using operator new function and then the constructor is invoked to initialize the memory. Here...
ACCUConf 2018 Trip Report Two weeks ago, I attended the ACCU Conference in Bristol again, and again it was a blast. ACCUConf is by far the most interesting and enjoyable confer...