On Monday, 30 August 2021 at 23:27:07 UTC, Merlin Diavova wrote:
```
After playing around the above works, Great! However I have
some questions
First, why do the interfaces have to be defined as `immutable
interface`?
The interfaces cannot be changed at runtime or instantiated.
It isn't required. And that's related to the answer to the next
question.
Secondly, why does defining the return type for withName as
`Project` give the `Error: 'immutable' method
'winry.project.Project.name' is not callable using a mutable
object`. However changing it to `immutable(Project)` works as
expected.
Applying immutable to a class or interface does not make
instances immutable. It makes member functions callable on
immutable instances. Example:
```d
import std.stdio;
interface Foo {
void bar() immutable;
}
class Baz : Foo {
void bar() immutable { writeln("Boo!"); }
}
void main()
{
immutable(Baz) b = new Baz;
b.bar();
}
```
Notice my application of immutable on the declarations of the
member functions. This means that the `bar` function is callable
through immutable instances of `Foo`.
When you apply immutable to the interface declaration, it has the
effect of applying it to every member function. You can see that
from the compilation error output when we modify the above to
this:
```d
import std;
immutable interface Foo {
void bar();
}
class Baz : Foo {
void bar() { writeln("Boo!"); }
}
void main()
{
immutable(Baz) b = new Baz;
b.bar();
}
```
```d
onlineapp.d(7): Error: class `onlineapp.Baz` interface function
`void bar() immutable` is not implemented
```
Member functions marked as immutable can be called on both
mutable and immutable instances. Member functions without it can
only be called on mutable instances.
This applies to const as well.
