Immutable nested functions

[Tomek Sowiński]

Daniel Murphy napisał:

> Defining a member function to be immutable doesn't mean it can only access 
> immutable member variables, it means it must be called with an immutable 
> class reference.
> 
> class C
> {
>   void fun() immutable {}
> }
> 
> void main()
> {
>   auto c = new C();
>   c.fun(); // error
>   auto i = new immutable C();
>   i.fun(); // ok
> }
> 
> For nested functions, the reference is to the enclosing function's stack 
> frame.  What does it mean to have this be immutable?  Maybe this makes sense 
> if EVERY variable in the enclosing stack frame is immutable?

Good point. I think the concept of immutable nested functions is still a solid improvement, even with requiring every variable of the enclosing stack frame to be immutable.

> Is there any reason you couldn't just use static nested pure functions?
> 
> void main()
> {
>   static pure Node* grow_tree(int breadth) // strongly pure
>   {
>     ....
>   }
>   immutable Node* tree = grow_tree(...);
> }

I fear one would need to tediously add arguments for *every* ingredient in the scope to be able to cook them inside. And if an ingredient turns out not necessary as the software evolves, there's the tedium of removing it from the nested function signature, which -- let's face it -- nobody does. Initializing immutable structures is fairly common and lack of a convenient way to do it has been recognized as one of the shortcomings of the const system. It can and should be solved.

-- 
Tomek