World: r3wp

:-)

It's nice when that works :)

sometimes...

But back on topic, we all know that Ladislav and Maxim have been 
using functions named INCLUDE to write their own code organizing 
or module systems over the years. But R3 has a standard module system 
already. We want to encourage people to use *that* module system, 
or to improve it if it isn't good enough for them. Code written for 
incompatible module systems is incompatible because of that, and 
thus can't easily be integrated or reused. This leads to fragmentation 
of the community code base, which we definitely *don't* want. Especially 
since the proposed standard library of community-provided R3 modules 
is supposed to be compatible with R3's module system, and each other.


So we definitely don't want to reserve the word "include" for use 
by alternative module systems, because we don't want people to *make* 
alternative module systems for R3 unless they are compatible supersets 
of R3's module system, which uses IMPORT instead (different concept 
too).


R2 is a different matter: We're already stuck with different module 
systems and incompatible code bases, and they have to keep working. 
Even if a R3-style module system gets backported to R2 (and it will 
be) it will have to be an optional addon. And if INCLUDE gets added 
to R3 as the opposite of EXCLUDE, there would be downsides to adding 
it to R2. We wouldn't be able to use it in any mezzanine code because 
the function would be overriden by Maxim's module system or Ladislav's 
non-modular code organization system. So INCLUDE probably wouldn't 
be backported.

Do we have anything in R3 that equals PREBOL? I use this pre-processing 
quite a lot to include code (features), logos, colors etc. user dependent.

It's the next thing on my list to rewrite PREBOL to be compatible 
with R3's module system. The syntax should be a compatible superset, 
but the internals will be a lot different.

It shouldn't be hard: R3's module dependencies are statically determinable, 
and the semantics can be translated to one-script form using known 
transforms. The module system was designed with this in mind.

This is, btw, the reason the module system doesn't have an INCLUDE 
function, and the reason for the limits of the IMPORT function.

Well, some of the limits anyways.

Yeah, discouraging that use in R3 is a good reason to call the function 
INCLUDE.

 - if I understand you well, by "discouraging that use in R3"  you 
 simply mean, that you discourage to use a Rebol preprocessor in R3 
 (since my INCLUDE is just that). Then, I see it as inconsistent, 
 taking into account, that later you expressed an opposite viewpoint.

we all know that Ladislav and Maxim have been using functions named 
INCLUDE to write their own code organizing or module systems over 
the years. 

 - I have to disagree with this. AFAIK, Maxim never used 'include 
 as a name for that purpose

(which is illustrated above by himself)

Neither of these systems are in general use

Gabriele has his own system too ...

So we definitely don't want to reserve the word 

include" for use by alternative module systems" - have to disagree, 
again. My INCLUDE is not an alternative to a module system - it is 
a preprocessor, as everybody using it knows.

I've got my own aswell, copy/paste

And probably Anton has one too

Is that a contest ?

It's the next thing on my list to rewrite PREBOL to be compatible 
with R3's module system. The syntax should be a compatible superset, 
but the internals will be a lot different.

  - hmm, reinventing the wheel? (my INCLUDE is already available from 
  rebol.org library and it has the properties you listed)

Oh that's it

You should not be to much alarmed, the "It's the next thing on my 
list" is his favorite motto ;-)

lol

And if INCLUDE gets added to R3 as the opposite of EXCLUDE,

 - funny. The opposite of EXCLUDE already exists. The only "but" is, 
 that it is not called 'include.

...and it exists in R2 as well as in R3

Graham: "Neither of these systems are in general use" - wrong, actually. 
Everybody using Rebol preprocessor is compatible with Include, and 
the "generality of use" of INCLUDE is higher, than you guess.

Ah, sorry, I forgot. I did not put it to Rebol.org, since there already 
was a simplified alternative from Carl, so INCLUDE for R2 as well 
as INCLUDE for R3 are only at http://www.fm.tul.cz/~ladislav/rebol/

(but you can find some doc on rebol.org)

when we are at it, the main doc is at http://www.rebol.net/wiki/INCLUDE_documentation

I'm conflicted. I can see the logic of Brian's INCLUDE (though still 
wondering if it should be a set operation), but I use Ladislav's 
INCLUDE heavily. For me, the important thing is that we all, Carl 
included, keep communicating and work to leverage community efforts.

Yes, I have an old include system too, using the INCLUDE function 
name. It's hard to stop using it, unfortunately. I am quite ok to 
have a native INCLUDE added and to mean the opposite of EXCLUDE, 
however.

Ladislav, what is the R3 opposite of EXCLUDE ?
UNION ?
ALTER ?

What Steeve wants (conditional APPEND), does not have the same meaning 
as UNION.

Gregg, I don't use the set operations very often (but I still want 
them there), but I do conditional APPENDs quite often, and I miss 
a native function for it definitely.

(Puzzle spoiler!) The opposite of EXCLUDE is UNION.

Neither ALTER, nor the newly proposed function are opposites of EXCLUDE.

I have alternative names for EXCLUDE/INCLUDE ..... EXPLODE/IMPLODE 
:-)

Anton - what do you mean by conditional append? If not found? find 
blk value [append blk value] ?

EXPLODE? Sounds as a good suggestion to me, if that name should be 
accepted ;-)

:-)

Pekr, yes.

Sorry, I meant a modifying INCLUDE, as being the opposite of a modifying 
EXCLUDE. We had a long discussion about this.

UNION is non-modifying. EXCLUDE is currently non-modifying, but misnamed 
because of that (shouldn't be a verb).

Ladislav, I have no problem in principle with adapting some of the 
code in your include stuff to make a PREBOL superset with inherent 
support for R3's modules. However, if your preprocessor doesn't support 
collecting modules with R3's module syntax, then it's of no direct 
use to me for R3 code. And the great thing about a PREBOL superset 
is that #include is *not* a function, it's a directive.

That's right.

I have had frequent need for modifying INCLUDE and EXCLUDE, but not 
as much need for the non-modifying stuff. To each their own.

The non-modifying version of EXCLUDE should be called EXCLUDING, 
if we want the part of speech right :)

Hmm, EXCLUDING's not a bad way to avoid clashing meanings for EXCLUDE.

A problem with INCLUDE is that it sounds like INSERT, but the functionality 
is APPEND (which is INSERT TAIL, ok). So what if we also want conditional 
INSERT ? I think we don't want it as often as APPEND, but it could 
be more flexible, allowing different positions to insert.

Is it really so bad to do conditional code with conditional code? 
We have IF, EITHER and UNTIL for a reason. They are not awkward.

It's not so bad, but it would be nice to have, if we could just come 
up with some good function names...