AltME groups: search

The idea per thread is neat, btw.


but I will be adding the expose refinement to import for sure... 
I just can't use other people's modules and hack them everytime they 
are updated... that is how slim started out... I was using someone 
else's module and everytime he did a release, I had to take 2 hours 
to fix up the module so it would work into my code.


that is the point of importing only the words you want... especially 
renaming them to remove clashes within your code and the module being 
used.  I don't see how that has ANY thing to do with the per-task 
concept  the source which uses a module, just makes it obvious where 
things are coming from and debugging is GREATLY simplified.

All module export in R3 is what you call exposing in slim. Importing 
is a separate issue, and you can choose what to import. The export 
list is just that: a block of unbound words that are used as a guideline 
about what to import - all module context words are actually visible, 
unless they are hidden using the standard hiding facilities. You 
can choose to import just that list, or none, or go by a module reference, 
or import whatever visible words you want. What importing means depends 
on what kind of module or script you are calling from, or for that 
matter whatever you want it to mean.


You need to remember the model if you are doing selective import 
though. You aren't just importing to the current context if you are 
importing named modules. If you come up with a good model for selective 
import, be sure to tell me. I think that I'm one of only a few people 
who really understands the whole model (must write more docs).

slim and R3 modules have a very similar model, as we discussed before, 
since I have the same concept of named/unnamed modules and they basically 
have the same limitations.

I just recently added a few features to slim and I had a lot of fun 
too :-)

just so its clear... 


wrt MODULES, I'm not at odds with the work you have done brian, which 
is very clean and well done... I'm at odds with the philosophy itself 
of the module model Carl decided to use.  It doesn't change anything 
wrt to R2's scalability problems, a part from removing paths in DO. 
 that's just my PoV and people aren't obliged to agree with it.  
:-)


python's module management is the best I've used, cause users have 
control, not the modules.  And since its a language based on the 
use of modules, I hoped we would follow that path.  but it seems 
not. what can I say.  

slim R3?  ;-)

I'd say that the chances that a R3 extension you forgot to bundle 
with your app happens to linger around in the Win32 system paths 
are pretty slim :)

souce code is 7MB, but probably includes a lot of stuff we can trim 
for our specific purpose. the binaries are big wrt rebol, so it can't 
part of the host code(unless brian can build a very slim version 
of it), but it would make for a very nice extension.

but I've now got slim working in R3  ;-)   am now working on converting 
liquid and other libs.

I'll eventually redesign slim so it uses modules though.

I really like how you've evolved the system and its doing all of 
what I wanted slim to do minus one or two little things, which I 
can easily graft over modules as they are .

modules within modules work fine from A108.  I've required this feature 
in CGR.  I am using the named version though (I'm conditioned by 
slim which also makes this the default and simplest use case).

in slim I also added an extension filename, in order to allow import 
by name to work with alternate extensions which is very usefull when 
you want to use the module system as a plugin mechanism for an application.

Thanks, Gregg. Some thoughts...


I create World, because I need the tool. So when I have the functionality 
planned, I've reached one of my goals, because I then have the tool, 
I need for my own future developments. For World to become a success 
for others to use also, it needs to be better in crucial ways than 
the tools, others use today. Therefore I also focus on making World 
slim (not bloated), stable and bug-free, very well defined, easily 
integratable and with good performance. There still is work to do 
in all these areas.