On 2010-11-15 16:52, Steven Schveighoffer wrote:
On Sun, 14 Nov 2010 05:28:29 -0500, Per Ångström <d-n...@autark.se> wrote:
Fortunately, by separating interface and implementation, one can at
least keep the implementation modules free from interdependencies.
It's not perfect but it's not a complete mess either.
It is one way to keep dependencies down. And less dependencies means
less coupling, meaning importing one module doesn't make you import (and
include the code for) many other modules. The compiler isn't yet mature
enough to trim out some code that is never used.
I have found a way to detect unwanted interdependencies between
implementation modules, by declaring a static constructor in those
modules that should not depend on other implementation modules.
// Student.d
import IStudent;
import ITeacher;
class Student : IStudent {
// ...
void ask(ITeacher teacher)
{
teacher.teach(this);
}
static this() {}
}
// Teacher.d
import ITeacher;
import IStudent;
class Teacher: ITeacher {
void teach(IStudent student)
{
student.learn(this, "knowledge");
}
static this() {}
}
Now if Teacher and Student were to accidentally import each other, I
would get a runtime error:
object.Exception: Cyclic dependency in module Student
However, I wish the situation could be detected at compile-time.
--
Cheers,
Per Å.
