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.

您可能感兴趣的

如何认识事物 在一个月明星稀的夜晚,你坐在阳台的躺椅上,手捧着银瓶梅,看得有滋有味。忽然天空闪过一道异光,一个外星生物蹦到了你面前,指了指你手上的那本书问道:这是什么? 你很想直接回答这是一本书,但这样对方可能对你发动超能力。那如何才能把「书」这个东西给讲明白呢?我们来试一下。 书是一种带有文字和图像...
C++ RCSP智能指针简单实现与应用 智能指针的实现代码来源博客:《http://blog.csdn.net/to_be_better/article/details/53570910》 修改:添加 get()函数,用以获得原始指针(raw pointer)。 其余思路来源《Effective C++》 智能指针的实现代码如...
In a class without virtual methods or superclass&a... I made a private API that assumes that the address of the first member-object in the class will be the same as the class's this-pointer... that way th...
Simulation of multiple instances of an integrated ... I'm working on a project which will entail multiple devices, each with an embedded (ARM) processor, communicating. One development approach which I...
Minimalist C Libraries In the past year I’ve written a number of minimalist C libraries, particularly header libraries. The distinction for “minimalist” is, of course, c...