Is there a way to forward-declare interfaces to avoid module interdependencies?

[Jacob Carlborg]

On 2010-11-11 13:10, Per Ångström wrote:
> I hope we can all agree that minimizing module interdependencies is a
> good thing, that a highly interdependent set of modules is generally
> harder to understand and more difficult to test than if the
> module-dependency chain is acyclic.
>
> With that in mind, suppose I have the following C++ code, organized with
> a separation of interface and implementation, with no circular include
> dependencies:
>
> // IStudent.h
> class ITeacher; // forward reference
>
> class IStudent {
> public:
> virtual void ask(ITeacher &) = 0;
> virtual void learn(ITeacher &, const char * knowledge) = 0;
> };
>
> // ITeacher.h
> class IStudent; // forward reference
>
> class ITeacher
> {
> public:
> virtual void teach(IStudent &) = 0;
> };
>
> // Student.h
> #include "IStudent.h"
> class Student : public IStudent {
> public:
> void ask(ITeacher &);
> void learn(ITeacher &, const char * knowledge);
> };
> // Teacher.h
> #include "ITeacher.h"
> class Teacher: public ITeacher {
> public:
> void teach(IStudent &);
> };
> // Student.cpp
> #include "Student.h"
> #include "ITeacher.h"
>
> void Student::ask(ITeacher & teacher)
> {
> teacher.teach(*this);
> }
>
> void Student::learn(ITeacher &, const char * )
> {
> }
>
> // Teacher.cpp
> #include "Teacher.h"
> #include "IStudent.h"
>
> void Teacher::teach(IStudent & student)
> {
> student.learn(*this, "knowledge");
> }
>
> // main.cpp
> #include "Student.h"
> #include "Teacher.h"
> int main()
> {
> Student student;
> Teacher teacher;
> student.ask(teacher);
> return 0;
> }
>
> Below is my attempt at porting the code to D2. I hope I'm missing
> something due to my limited experience with D, but it seems D forces me
> to create circular dependencies between modules ITeacher and IStudent,
> since I cannot find a way to forward-declare types external to the
> current module in D like in C/C++.
>
> // IStudent.d
> import ITeacher; // would like to forward-declare the interface instead
>
> interface IStudent {
> void ask(ITeacher);
> void learn(ITeacher, string knowledge);
> }
>
> // ITeacher.d
> import IStudent;
>
> interface ITeacher
> {
> void teach(IStudent);
> }
> // Student.d
> import IStudent;
>
> class Student : IStudent {
> void ask(ITeacher teacher)
> {
> teacher.teach(this);
> }
> void learn(ITeacher teacher, string knowledge)
> {
> }
> }
> // Teacher.d
> import ITeacher;
> import IStudent;
>
> class Teacher: ITeacher {
> void teach(IStudent student)
> {
> student.learn(this, "knowledge");
> }
> }
>
> // main.d
> import Student;
> import Teacher;
> void main()
> {
> auto student = new Student;
> auto teacher = new Teacher;
> student.ask(teacher);
> }
>
> So my question is: Am I missing something, or is this the D way to do it?
>
> Cheers,

First you have to import ITeacher in Student.d (if I'm reading this 
right). Second, D has (generally) no problems with circular references. 
You only get problems when two modules is a part of a circular reference 
and both have module constructors. If you porting C++ code you will not 
have this problem since C++ doesn't have module constructors.

BTW, you generally don't separate your interface and implementation in D 
(you can to that if you want to hide your implementation).

The import/module system in D is more like the one in Java than the one 
in C/C++.

-- 
/Jacob Carlborg