On Sun, 08 Mar 2009 06:44:48 +0300, Jason House <[email protected]>
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
