folder naming like internet subdomains

7.12: adda/dstr/folder naming like internet subdomains:

. in the naming system for subsystems,
the naming of a folder can have a special meaning
because the folder represents
something like a website;
so, just as the top domains
(.com, .org, .net ...)
indicate a website's role type,
these folder types ( .pkg, .type )
can indicate top level domains in our
network of modules .
. later that system would change so that
(.pkg) was the implicit datatype
of any untyped folder
if it was within adda's path .]

. a module can be divided into several folders
by using subdomains; eg,
given these top-level modules:
( int.num.type
, real.num.type )
we can see that both int and real
belong to the same datatype, num;
so, when importing num.type
we're reaching all the folders named *.num.type .

8.8: on the other hand:
. why use *.num.type
to find all of num's subtypes,
when all are known? (they belong to num,
so they should simply be inherited by num).
-- need to find some other use case .
. if a compelling use case is
to simply give the user another tool for
dealing with partial names,
then searching for (num.type)
finds only (num.type);
so you have to import ( *.num.type )
to reach {int, float, etc}.num type .

8.8: url's top-domain notation?:
. I'm leary of the above idea;
because, the inventor of url notation
said he regretted it!
Berners-Lee 2000/09:
"( I have to say that now I regret
that the syntax is so clumsy.
I would like http://www.example.com/typical/unix/path
to be written as http:com/example/typical/unix/path
. It turned out the shorthand
is rarely used
and so we could dispense with the "//".
When I was designing the Web,
I tried to use forms which people would
recognize from elsewhere.
I wanted the syntax of the URI
to separate [the server's name
from the name of the resource being requested .]
The relative URI syntax is from unix;
Then I needed an extension
to add the service name (hostname).
. the Apollo unix domain system had already
extended the filename syntax like so:
So I just copied Apollo. )
. after inventing url notation,
he later wanted it to match the way
dot notation is used in records,
(record syntax is like this:
 obj.partOfObj.partWithinPart )
which means an url that now looks like this:
would instead look like this:
com.domain.subdomain .
. as you can see from my source's quote,
I had not remembered what he said accurately;
the point was not that
subdomain.eg.com should be com.eg.subdomain;
rather, the point was that people's names
should not have to include their top-level domain,
because, something technical like that
should be in a separate folder with the protocol .
. his example also seems to suggest that
since the www subdomain will be so common,
it shouldn't even be mentioned .]

. I definitely like the idea from filetypes:
so, I would be partial to url's like this:
domain.com/subdomain/ .