best approach to code hierarchical classes ?

[someone]

On Tuesday, 8 June 2021 at 02:05:27 UTC, Paul Backus wrote:

> Your module and class are both named `classComputers`, with an 
> `s` at the end. You should change one of the to have a 
> different name so that there's no ambiguity.

dmd output:

./dm.d(49): Error: undefined identifier `classComputer` in module 
`dmclassescomputers`, did you mean class `classComputers`?
./dm.d(50): Error: undefined identifier `classComputer` in module 
`dmclassescomputers`, did you mean class `classComputers`?
./dm.d(51): Error: undefined identifier `classComputer` in module 
`dmclassescomputers`, did you mean class `classComputers`?
./dm.d(53): Error: no property `outer` for type 
`dmclassescomputer.classComputer`

file [dm.d] as following:

```d
import dmclassescomputers = dmclassescomputers;
///import dmclassescomputer = dmclassescomputer;

import std.string;
import std.stdio;

void main (

    ) {

    auto lobjComputers = new 
dmclassescomputers.classComputers(r"lab"c);
    lobjComputers ~= lobjComputers.new 
dmclassescomputers.classComputer(r"dell"c); /// <- line 49
    lobjComputers ~= lobjComputers.new 
dmclassescomputers.classComputer(r"ibm"c);
    lobjComputers ~= lobjComputers.new 
dmclassescomputers.classComputer(r"apple"c);
    lobjComputers[1].name = r"lenovo"c;

    foreach(lobjComputer; lobjComputers) { writeln(r"["c ~ 
lobjComputer.outer.network ~ r" network has "c ~ 
lobjComputer.name ~ r"]"c); }

}
```

file [dmclassescomputers.d] as following:

```d
module dmclassescomputers;

import std.string;

class classComputers {

    classComputers lhs;
    classComputers rhs;

    int opApply(int delegate(dmclassescomputer.classComputer) dg) 
{ /// boilerplate code to handle the class's default collection

       int lintResult = 0; /// must find a better name

		foreach (lobjComputer; computers) { /// looping over the 
computers starting in current node

			lintResult = dg(lobjComputer); /// passing single object to 
the loop body

			if (lintResult != 0) { break; }

		}

       if (lintResult != 0 && lhs ! is null) { lintResult = 
lhs.opApply(dg); } /// recursing child nodes
       if (lintResult != 0 && rhs ! is null) { lintResult = 
rhs.opApply(dg); } /// recursing child nodes

       return lintResult;

    }

    public dmclassescomputer.classComputer[] computers; alias 
computers this; /// ie: default property

    private string pstrNetwork;

    final @property string network() { return this.pstrNetwork; }
    final @property void network(in string lstrNetwork) { 
this.pstrNetwork = lstrNetwork.strip(); }

    this(
       string lstrNetwork
       ) {

       this.network = lstrNetwork;

    }

    import dmclassescomputer;

}
```

file [dmclassescomputer.d] as following:

```d
module dmclassescomputer;

import std.string;

class classComputer {

    private string pstrName;

    final @property string name() { return this.pstrName; }
    final @property void name(in string lstrName) { this.pstrName 
= lstrName.strip(); }

    this(
       string lstrName
       ) {

       this.name = lstrName;

    }

}
```