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

function hidden_arg( name ) {
    name = "weird"


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.

责编内容by:Musing Mortoray 【阅读原文】。感谢您的支持!


Skyline桌面二次开发之路径漫游(C#) 所谓路径漫游:即创建一个动态对象和一条由多点组成的线,然后让动态对象沿着线飞行 首先绘制一条线,实际上路径漫游是不需要绘制线的,我这里只是为了确认动态对象是...
Finding memory bugs in D code with AddressSanitize... LDC comes with improved support for Address Sanitizer since the 1.4.0 releas...
C++ 开发 PHP 7 扩展之定义常量 大家如果经常阅读 PHP 官方手册的话会发现,在扩展那一章里面的每个扩展的介绍的时候,都有一节是 Predefined Constants 预定义...
UML Modeling for C++ with UModel C++ is one of the most powerful and efficient programming languages available, t...
Find length of longest subsequence of one string w... Given two string X and Y . The task is to find the length of longest subs...