Returning const? -- A potential solution

[Denis Koroskin]

On Sun, 08 Mar 2009 06:44:48 +0300, Jason House <jason.james.house at gmail.com> wrote:

> The ugly const thread got me thinking about the old problem of returning  
> an
> input while preserving const safety.  I have an idea that seems
> reasonable...
>
> In a nutshell, I'm thinking that const(T) should be a base type for T,
> immutable(T) and return(T).  return(T) is treated in a read-only fashion,
> just like const(T) and immutable(T). Here are some of the key things I  
> think
> this achieves:
>   * Input arguments are never mutated
>   * Use of input parameters in calls to functions as const(T) is 100%  
> legal.
>   * Temporary variables can legally be defined and used
>   * Calling other functions that return return(T) is allowed
>   * No code duplication
>   * No code bloat (compiler only needs to generate one version of the  
> code)
>   * Functions can be virtual
>
> Let's take a relatively simple example: max
>
> return(T) max(return(T) a, return(T) b){ return (a>b)?a:b; }
>
> When max is called, the compiler would examine the inputs for a and b to
> determine what the true type for return(T) is from the callee's
> perspective...  So a call with T and immutable(T) would use const(T) as  
> the
> perceived return type while an argument of T and T would use T as the  
> return
> type.
>
> At the call site, the compiler would ensure type safety of how the return
> type is used.  Within max, the compiler would ensure that the arguments  
> are
> either treated as const(T) in function calls but not mixed with with  
> types
> T, const(T), or immutable(T)
>
> PS: The return(T) notation is an arbitrary one for the purposes of this
> post.  We need a technical solution before worrying about the color of  
> the
> bicycle shed
>

How about this one?

class Foo {
    T value() {
        return _value;
    }
    T value() const {
        return _value;
    }
}

You suggest turning it into:

return(T) value() {
    return _value;
}

Which is fine but it doesn't say anything about constness of 'this'.

In fact, you propose *exactly* the same thing I've been proposing multiply times in past under a different name, though:

sameconst(T) max(sameconst(T) a, sameconst(T) b) {
    return (a > b) ? a : b;
}

class Foo {
    sameconst(T) value() sameconst(this) { // return value has the same constness as 'this' (mutable, const or immutable)
        return _value;
    }
}

The constness is automatically propogated based on parameters. For example,
- sameconst(T) == T if all the parameters are mutable
- sameconst(T) == immutable(T) if all the parameters are immutable
- sameconst(T) == const(T) otherwise