AltME groups: search

http://www.compkarori.com/reb/download-manager.r


is a wrapper around Anton's batch download script.  It reads a configuration 
file(s) from a site and loads the data into the script.

This is as: file description url and then extended file description.

Defaults are embedded into the script and are used if the read fails.
You can use it to download iso files etc.

Thanks, you identified a problem with my ftp send-to utility!

run the script. it needs some mb  sprites, which i get from another 
website. http://reinerstileset.4players.de/T_dino_green.zipand http://reinerstileset.4players.de/Tblue knight.zip 
.

when you run it, it makes a %sprites/ - folder in its dir. unzip 
the sprites in folders, %T_dino_green.zip in T_dino_green/ etc. and 
put these folders in the %sprites/-folder .

click "zum spiel" and avoid the dino.. (or, ctrl+cursor  swings sword 
:)

It says that because that is the date the original entry was created. 
 We created a few blank records and update them at the right week. 
I guess we should look at the template and remove that information.

A few announcements...


A simple to use progress indicator I use in my automation scripts...

www.practicalproductivity.com/files/progress.r

Snip and splice, must-haves for text processing...

www.practicalproductivity.com/files/snippers.r


The following is not well tested, so feedback is welcome. Its some 
tools for working with headers and allows you to disable http redirects...

www.practicalproductivity.com/files/http-tools.r


If you have wrist issues from using the mouse, try Joystick Navigator 
(windows). No rebol inside, but it may help make more rebol software.

www.practicalproductivity.com/joy-nav/


btw, I have a patch for sending html emails. Its pretty rough at 
this point, so contact me if you must have it.

Standalone VPRINT (verbose print)  implementation released on rebol.org. 
 This is the most advanced output/logging management utility for 
REBOL AFAIK.


features:  Extremely easy to setup and use (direct drop-in equivalent 
Print/Prin/probe/??  implemented ... even in logs :-),   hierarchical 
nesting of any output (tracing),  transparent logging,  on-the-fly 
selection of output,  "allow and deny"  any combination of individual 
tags to be output/logged ,   postponed output buffer for tight loops 
(not implemented for log). 

BSD license.


Instead of using pre-defined "levels" of verbosity, you associate 
individual print statements with (one or more) conceptual tags.  
Then you can programatically switch the desired output tags on the 
fly.  Effectively allowing only one function or a whole group of 
them to be displayed OR logged with one setup call when they are 
next encountered.    


The logging tag selections are independent from the console output 
so you can choose to display more or less of what you log out.  In 
fact, you can even log different output than what is printed.


This tool is not beta, it is being used in commercial environment. 
 It is very stable AFAIK and fully-featured.

New installement of "The REBOL Week" available.   A LOT happening, 
and a fresh new layout.   :-)
http://rebolweek.blogspot.com/

Mailing List Archive tagging project has reached a major milestone:

http://www.rebol.org/cgi-bin/cgiwrap/rebol/ml-display-message.r?m=rmlWJKC

Get a parse tree result from Parse


http://www.rebol.org/cgi-bin/cgiwrap/rebol/documentation.r?script=load-parse-tree.r


For fans of REBOL's Parse function, it could be particularly useful 
used with Gabriele's Rewrite function.

It is my pleasure to announce, that Cyphre was contracted to bring 
what I regard latest limiting factor for RebGUI database experience 
- a grid. The grid should support following features - visible/non-visible 
columns, both vertical/horizontal scrolling, keyboard support, programmable 
navigation, tri-state columns sorting, possibility to put other styles 
in cells. Expect it being in the middle of capabilities of RebGUI 
table, and Henrik's grid. The grid should be also easily portable 
to VID. The license - BSD.


Other things Cyphre will look into with regards to Rebgui is, how 
to make RebGUI a bit more pretty, centralising other things or simply 
allowing gradients for tabs etc. That is subject to change.


On non RebGUI front, we should have better sys-tray support under 
Windows, probably via .dll ....

The time-frame is three weeks from today. Stay tuned!

Fix for MySQL driver released today (v1.0.7):


 o Fixes a comptability issue in handshaking with new servers using 
 old passwords format.

See http://www.softinnov.org/rebol/mysql.shtml

TOOLBAR version 0.0.3 released.


Toolbar is a new layout function for creating a MacOSX or Windows 
style toolbar for VID.

Files:

http://hmkdesign.dk/rebol/toolbar/toolbar-manual.html
http://hmkdesign.dk/rebol/toolbar/toolbar.r
http://hmkdesign.dk/rebol/toolbar/toolbar-demo.r

PAN-IMAGE version 0.0.1

http://www.hmkdesign.dk/rebol/panimage/pan-image.r


This is just a face which allows panning of an image larger than 
the face, by dragging the mouse around on the image. Supports keyboard 
and scrollwheel.

USAGE: view layout [pan-image 300x300 <huge-image>]

Sorry if you know it, I found it by accident and I really like it, 
just a shame, that the france chars are wrong with my czech regional 
settings (but the chinnese chars look good and the animations... 
really good work)

A UPnP pilot is on the library here : http://www.rebol.org/cgi-bin/cgiwrap/rebol/view-script.r?script=upnp-igd.r


Run it and you will discover all your UPnP device on your lan if 
any (lan printer, internet gateway and other lan equipement). It 
will also list your port mapping on your internet gatway if any. 
To run it, if needed, open your firewall for UPnP connection.


The objective is to help anyone how wants to develope and run server 
on their PC with an automatic port mapping for incomming connection.


For example, if  AltMe embed this tool, running a world on my PC 
would be more simple as no more NAT configuration is needed to route 
incoming connnection.

there is a zip file containing everything

Oldes, you either have very fast hands or a very fast computer or 
both. I can't get close to your record even using your code. But 
isn't it amazing what be done with just one line of rebol code?

HTTP Tools. A small script containing a few functions to read the 
HTTP header of a webserver. It doesn't do much, but the main purpose 
is to determine which scripting language is used on a specific webserver. 
I use it to upload ASP and PHP scripts to various webservers, without 
having the user needing to know the scripting language in advance. 
It's not very strong yet and some servers will not reveal this information, 
but I hope it can be built into a reliable tool for determining scriping 
language over time.

http://hmkdesign.dk/rebol/http-tools/http-tools.r

Example:

>> server-type http://rebol.com
== "Apache"
>> x-power-type http://www.hmkdesign.dk
== "php"
>> x-power-type http://www.microsoft.com
== "asp"

maybe you should change name as there is already script with such 
a name in the library http://www.rebol.org/cgi-bin/cgiwrap/rebol/view-script.r?script=http-tools.r

I'll make a first public release this week-end.

REBOL [
    Title:   "Slideshow"
    Date:    12-Oct-2006
    Name:    'SLIDESHOW  ; For window title bar
    Version: 1.0.0
    File:    %slideshow.r
    Author:  "Louis A. Turk"
    Rights:  "Public Domain; use at your own risk."
    Needs:   "A version of REBOL/VIEW supporting sound"

    Purpose: {To make possible simple, easy to make narrated slide shows.

              Hopefully can be used with the REBOL plugin to show narriated slides
              on a web site.

              Hopefully can an effective tool to teach REBOL programming.
    }
    Note: {
        The concept and design originated with Louis A. Turk.

        DideC helped considerably by answering programming questions and 
        giving bits of code;
        it would not have been possible without his help.
	Josh also answered programming questions.


        You can make wav files using the free program Audacity. http://audacity.sourceforge.net


        Advanced JEPG Compressor does and excellent job compressing graphics 
        files so they load 
        faster, but is not free.
    }
    History: [
        1.0.0 [ "First release." "Louis"]
    ]

    Language: 'English
]

;Requires a data file named %slides.r containing lines of blocks 
in the following format:

;Each block must contain: (1) slidename, (2) overlay, (3) caption, 
(4) sound.

;Example block: [%slide1.jpg "Overlay text." "A caption!" %sound.wav]
;Use "" for no overlay or caption.


;file: request-file/title/only "Select the slides data file to use." 
"Select Data File"

file: %slides.txt ;uncomment the above line, and comment this one 
to select data files with different names.
slides: load file
narrate: func [talk] [ ;--- Manage the sound
    sound-port: open sound://
    insert sound-port load talk
    wait sound-port
    close sound-port
]

view/new win: layout/size [] 650x650 ;<= Set the max size you need
wait 0  ;---Initialize REBOL's internal event handler.
foreach slide  slides [ ;--- Start the slide show
    set [graphic overlay caption narration] slide
    lay: layout [
        origin 0

        banner center bold red "A REBOL Produced Narriated Slide Show" 
        image graphic overlay 500x400 frame black [unview] [quit]
        text 500 bold caption
        button "Quit" center [quit]
    ]
    center-face/with lay win
    append clear win/pane lay
    show win
    narrate narration
]
do-events

This is a center-face problem. It assumes you are talking about two 
window faces. You can closely mimic the center-face behaviour though.
Replace the line
	center-face/with lay win
by
	lay/offset: max 0x0 win/size - lay/size / 2

perhaps we need a null datatype ?

only that .. need a way to distinguish.

but block is kind of storage for us ... so the trouble is, that we 
may obtain those nulls from two different reasons - as a result of 
an operation, or simply because we wrongle adress block itself ... 
not sure what we can do about it :-)

isn't this the issue of using an ordinal on a block with NONE as 
an element?

I use it as a shortcut for not none?

Perhaps we need a way to configure the behaviour we want?

if your data doesn't have none, then you can accept none for a range 
error.

I suspect it was a mistake to allow an out of range to return none.

Regarding pair and decimals; would it make sense to generalize pair 
further into a new vector datatype, that can be any dimension more 
than one? Examples: 2.4x8.0x5.5 would be a 3D vector with coords 
(2.4; 8.0; 5.5). Like the same idea with tuples, which can be 3 or 
more bytes separated by dots: 255.255.255, 255.255.255.255,... etc.

Imagine having a matrix! datatype:
m: make matrix! 4x4
Then you could find the determinant like for example:
m/determinant
That would be a miracle! :-)

it would also be a miracle to be able to have a complex! datatype. 
I think electronic engineers would appreciate that

How to submit a suggestion to Carl?

Geomol, Rambo the suggestion for a vector datatype.

well, I'm really not sure about the notation as I haven't given it 
too much thought, so I can't give a valid example, but if you could 
say:

>> 6 / 2
== 3

>> 6 [m] / 2 [cm]
== 300 [cm]

It that something for a dialect rather then to be inlcuded in the 
core langauge?

I think it's worth making a concept dialect for scientific math with 
units

actually, it would be good to make a ctx-unit to handle units exactly 
like the hp48 does

the hp48 uses an underscore to attach the number to a unit: 6_m / 
23_cm

http://www.apple.com/downloads/macosx/math_science/eurekalc.html
<-- I think that could be done with a dialect...

that calculator needs a spell checker as well!

Graham, I've made a RAMBO proposal for vector and matrix.

how do you find the 4th part of a 4D vector?

A quick google took me to the Python page - "The 4th component can 
be accessed either by the name w or t." 

http://cgkit.sourceforge.net/doc2/vec4.html

Peter, ok idea, and I'm all for that. There just shouldn't be a limit, 
and we have to use integers to reach later parts of a vector ... 
like with series.

don't know why we just don't start with "a" and work our way thru 
to "z"

There also seems to be a convention of x y z t u v

t, u and v is probably found a lot in 3D graphics math.

I'm sure that there is a mathematical convention and would be surprised 
if Carl S doesn't know it.

All different kinds of 3D manipulation will look simple, like scaling, 
rotation, reflection, etc. All those are well-defined matrix-operations. 
And supporting multi-dimensional vectors and matrices might pull 
a lot of science people to REBOL.

but x might be a word.

Reaching second element on second row in a 2-dimensional matrix:
M/2x2

And of course we should have matrices with more than 2 dimensions, 
so something like this is possible:
M/2x2x2

So pairs need to be extended somehow into a datatype, which is like 
a vector, but with integers instead of decimals.

like this: a: [ [ 0 1] [ 2.2 3.1]]  a/2/1

Geomol: "So pairs need to be extended somehow into a datatype, which 
is like a vector, but with integers instead of decimals." --- decimal! 
is better in my opinion. It's consistent with current behaviour whre 
you can do 
>> block/4.5
and decimal part is truncated.

but with matrix we can     a: make matrix! [ [ 0 1] [ 2.2 3.1]]  
a/2/1

if pair will be extended it overloads 16 byte limit for slot and 
become a series datatype, something complety different. there can 
be only 10 bytes per value ( I don't know exacly but tuples can have 
only 10 bytes not more)

during a bath, I thought up a Grand Master Plan:


1. Build a dialect that could handle scientific/symbolic math on 
the hard core level

2. Make it possible to take an equation and draw it up correctly 
with DRAW, a pretty print equation display. The same dialect would 
be used as above.

3. Use that to display pretty equations inline in makedoc2/3 documents!

4. Some people are working on a postscript dialect which hopefully 
eventually will be able to use DRAW blocks as an input, thereby allowing 
you to create equations on the console and convert it to DRAW or 
PS at the same time as having the ability to do calculations. That 
would be powerful.

Say:

calculate [2 [m] / 3 [cm]] ; would return the result as needed
calculate/draw [2 [m] / 3 [cm]] ; would return a DRAW block

postscript calculate/draw [2 [m] / 3 [cm]] ; would convert that DRAW 
block to postscript

now there is just the problem of doing symbolic math in such a block. 
you'd need specific functions for that, I think.

in a sense, I feel, some proposals from Carl stray away from rebol's 
current orthogonality ?

most people stop when they actually try to do a concrete application 
within constrains and realise many things within the implementation 
of this or that... well, just falls short of working.

rebol claims a lot of things... but falls short in general.   for 
my latest project, I had to re-implement http posting, and xml parsing 
myself and I'm still not finished.

rebol feels like a hybrid car.  Almost, but note quite enough to 
get new people out of their cosy stylish cars.   Its got a lot of 
promise, but at what cost.

are you on a mission to disable all scripts in the world  ;-)

So, for a SELECT, you won't have to search around with your eyes 
for the VALUE argument, as in this example from the FTP scheme which 
I am currently looking at:

we must question if such a change is better if it means newbies cannot 
use any public rebol code on rebol.org, for example.

same with FIND. it's not natural to say "Find in the kitchen a pot" 
in English

Isnt 'switch exactly that, a reversed "do select"? i use 'select 
on variables, not blocks. then it is
> select data face/text

About english, "Find in the kitchen a pot" is ugly, but "look in 
the kitchen for a pot"?

look in

 seems to be correct enough. I'm just used to finding the pot in the 
 kitchen, not finding in the kitchen a pot, thus I usually swap the 
 function arguments by mistake.

anyone know why the priorities of +, - and *, / are swapped. This 
is a little annoying, I think.

a tend to agree with you, but some people say that priorities force 
them to rethink their expressions...

It's explain in the doc : priority go from left to right, nothing 
more. The rule is different than the mathematical one we used to 
use. But it's also a "simple" rule, easy to remember.
So, 
>> 3 + 2 * 5
== 25

gabriele: luckily, Brett had a copy:

http://www.rebol.org/cgi-bin/cgiwrap/rebol/ml-display-message.r?m=rmlLNJK
Otherwise the trail could have ended here:

http://www.rebol.org/cgi-bin/cgiwrap/rebol/ml-display-message.r?m=rmlXSDC

Priorities would mean more special cases for the evaluation - instead 
of a consistent op! behaviour.

It's not just + * - /, it's for // ** and or xor = > >= <= <> == 
=? too.

The left to right rule is itself quite an improvement in readability 
over the pure form:
>> * + 3 2 5
== 25

Petr, about custom types, probably yes, but I don't think this has 
been decided yet; In case we have them, i think that at least TO 
needs to be implemented as a multimethod; then having multimethods 
in general might make sense... but I don't think this is going to 
be very high priority (there are more important things).

I18N is partially discussed in the Unicode group, I'm not sure it 
has come up on the blog other than it being a goal, as with L10N...

I don't think there is a group here specifically geared toward localization, 
though I know it's a well discussed issue...

From the Roadmap: "Greater Locality Support 

It's time for REBOL to do a better job at supporting native languages 
and character-sets. Our goal to expand support with locality and 
unicode enhancements. In addition, it is a goal to release 3.0 with 
French, Italian, and perhaps one/two other languages as part of the 
standard distribution."

Yes I thought that that was a strange move... French and Italian..I 
can understand Localisation towards French and Spanish though.. and 
perhpas Asian or Arabic..but what is so special about Italian? (Many 
rebol projects in Italy perhaps?)

My current job is localisation engineer working on some big software 
and I must say that current localisation/internalisation state is 
total mess. How do I miss good old Amiga catalogs! Such a simple 
idea and still not adapted on Windows. We do patch dlls directly...terrible. 
So I hope R3 will bring something like Amiga Localisation System.

Is anyone intersted in improving the library interface in R3? I have 
a lib dialect (just posted to REBOL.org), and some notes I'll post 
here. Is it worth some time to put suggestions together for RT, or 
is everyone OK with the existing system?

The current library interface is servicable, but could be improved.

For example, char arrays in C structs are a real pain to deal with,

there is redundancy if you're importing a number of routines, from 

the same library, and extra work is required to deal with pointers
to values.

The biggest issue for me seems to be that I have to use COMPOSE 

heavily to get the results I want, or there's a lot of duplication
in struct and routine defs.

--- Easier Routine Declarations

The only thing I've addressed in my lib interface dialect is
making it easier to declare routines. I posted it to REBOl.org
for discussion:


http://www.rebol.org/cgi-bin/cgiwrap/rebol/view-script.r?script=lib-dialect.r

--- Pointers


This is maybe a bit of an extreme example, but I had to do it, so 
it's not purely theoretical.

    LPINT-def: [value [integer!]] none

    LPINT: make struct! LPINT-def none

This struct shows where a nested struct is needed.

    _FAX_JOB_PARAM-def: compose/deep/only [

        SizeOfStruct    [integer!]      ; DWORD structure size, in bytes

        RecipientNumber [string!]       ; LPCTSTR   pointer to recipient's 
        fax number

        RecipientName   [string!]       ; LPCTSTR   pointer to recipient's 
        name

        Tsid            [string!]       ; LPCTSTR   pointer to transmitting 
        station identifier

        SenderName      [string!]       ; LPCTSTR   pointer to sender's name

        ;SenderName      [struct! [value [string!]]]       ; LPCTSTR   pointer 
        to sender's name

        SenderCompany   [string!]       ; LPCTSTR   pointer to sender's company

        SenderDept      [string!]       ; LPCTSTR   pointer to sender's department

        BillingCode     [string!]       ; LPCTSTR   pointer to billing code

        ScheduleAction  [integer!]      ; DWORD job scheduling action code

        ;ScheduleTime    [struct! (SYSTEMTIME-def)]        ; SYSTEMTIME  
          time to send fax
            wYear       [short]
            wMonth      [short]
            wDayOfWeek  [short]
            wDay        [short]
            wHour       [short]
            wMinute     [short]
            wSecond     [short]
            wMilliseconds [short]

        DeliveryReportType  [integer!]      ; DWORD e-mail delivery report 
        type

        DeliveryReportAddress [string!]     ; LPCTSTR   pointer to e-mail 
        address

        DocumentName        [string!]       ; LPCTSTR   pointer to document 
        name to display
        CallHandle          [integer!]      ; HCALL reserved
        ;_PTR   Reserved[3]  [integer!]      ; DWORD must be zero
        _PTR-0  [integer!]      ; DWORD must be zero
        _PTR-1  [integer!]      ; DWORD must be zero
        _PTR-2  [integer!]      ; DWORD must be zero
        _PTR-3  [integer!]      ; DWORD must be zero
    ]
    _FAX_JOB_PARAM: make struct! _FAX_JOB_PARAM-def none
    _FAX_JOB_PARAM/SizeOfStruct: length? third _FAX_JOB_PARAM

    fax-complete-job-params: make routine! compose/deep/only [

        JobParams     [struct! (LPINT-def)] ; ptr to job information struct

        CoverPageInfo [struct! (LPINT-def)] ; ptr to cover page struct
        return:       [integer!]
    ] winfax.dll "FaxCompleteJobParamsA"

So, the API call returns pointers to structs containing the 
data we want; to get it we need to dereference the pointers
after the call.

    complete-job-params: func [
        /local
            params-ptr cover-ptr    ; API return pointers

            params cover            ; REBOL structs with data from API
    ][
        ; allocate return pointer structs for API call
        params-ptr: make-LPINT
        cover-ptr: make-LPINT

        ; make the API call

        reduce either 0 <> fax-complete-job-params params-ptr cover-ptr [

            ; get data from pointers returned by the API

            params: get-dereferenced-data params-ptr _FAX_JOB_PARAM-def

            cover:  get-dereferenced-data cover-ptr  _FAX_COVERPAGE_INFO-def
        ...



Getting the de-ref'd data is the real pain, and seems like it might
be unsafe in the way I did it, though it worked.

    get-dereferenced-data: func [

        {Given a pointer to memory, copy the target data into a REBOL struct.}

        pointer [struct!]   "LPINT structure whose /value is the data pointer"

        struct-def [block!] "The struct you want returned with data"
        /local struct data orig-pointer result
    ] [

        struct: make struct! compose/deep/only [ ; make wrapper struct
            sub [struct! (struct-def)]
        ] none

        orig-pointer: third struct              ; store original inner pointer

        change third struct third pointer       ; change inner pointer to 
        ref'd data

        data: copy third struct/sub             ; copy data from the inner 
        struct

        change third struct orig-pointer        ; restore inner pointer

        result: make struct! struct-def none    ; make result struct

        change third result data                ; change data in result struct
        struct: data: orig-pointer: none
        result
    ]


--- char arrays in structs, or as routine parameters

You can't just declare a fixed size block or string to do this, 
you have to (AFAIK), have individual elements for each item.
That's a huge pain if you have a 128 element array, so I end
up generating them dynamically. I think that was Cyphre's idea
originally, but I don't have notes on it.

    make-elements: func [name count type /local result][
        if not word? type [type: type?/word type]
        result: copy "^/"
        repeat i count [
            append result join name [i " [" type "]" newline]
        ]
        to block! result
    ]

    GUID: make struct! GUID-def: compose [
        Data1   [integer!]  ; unsigned long
        Data2   [short]     ; unsigned short
        Data3   [short]     ; unsigned short
        (make-elements 'Data4 8 #"@")  ; unsigned char
    ] none


--- MAKE-ing structs

How do other people make structs from prototypes? 

    make-struct: func [prototype /copy /with data] [
        make struct! prototype either copy
            [second prototype]
            [either with [reduce [data]][none]]
    ]


--- BSTR type

I've only needed it for one project, but it might be worth 
finding out if it would be worth adding BSTR support for
Windows, as a routine datatype.

in the best of worlds I'd prefer it if we could read all the info 
from a .h file and convert it into a rebol file ready to load the 
dll...
Gregg, Do you think this is possible?

Max, you want a C pre-processor. Lots of work. I think something 
like swig will be easier.

I did a .h file parser a long way back... it was able to find and 
extract function names... but did not tackle the structs....

couldn't we just base a preprocessor based on something already on 
the net?  arent' there some grammar-based C pre-processor a PARSE 
guru could convert into a dialect?

Well it sort of works. SWIG is what a lot of languages use.

When i onceneeded header-fields, i wrote a little program to output 
themand run it.
  print("%i",(&p.selector - &p));

Is there a particular reason why the left hand corner in draw is 
0x0, and not the bottom left corner?

is there a reason why we want to start the origin elsewhere?


From most daily activities, origin for drawing , writing, reading, 
tends to start from top-left.

I made a .h header file parser, which handled function names, typedefs, 
structs, and enums. It was made specifically for FMOD and FMOD EX 
libraries, but it is pretty general, able to be tuned for other libraries 
"fairly" easily.  Swig is probably the ultimate way, though it's 
not as easy as it sounds on the cover, and you might lose associtated 
documentation found in comments next to functions, struct elements 
etc.

I think with Swig you still need to be prepared to dive in pretty 
deep and swim around tying things together for a while.

I've done some little C processor dialect ideas as well, mainly to 
handle DEFINEs and convert structs to REBOL friendly data. I think 
those kinds of tools are useful and, for the amount of use they get, 
I prefer that approach to trying to do a complete C processor/loader. 
Ultimately, that might be good for some people, but I still want 
an interface dialect in REBOL that makes things easy to read and 
understand from a REBOL perspective. I think "dialect first, then 
tools".

I'm also willing to accept tradeoffs. I'd rather have a tool that 
can handle 80% of common C files, than to say it can't be done because 
of the other 20%.

For anyone who has written these kinds of tools, should we collect 
them all and see if we can come up with a spec we like, that is better 
than what we have today (e.g. that addresses the things that are 
painful today)? Does anyone want to be in charge?

About mezzanines in REBOL 3.

Instead of having hundreds (or thousands) of mezzanine functions, 
will it be a good idea to put those in includes? Problem with lots 
of mezzanine functions is, that programmers might have their own 
similar words, that then redefine the default ones.
(The same can be said with natives, of course.)

Or to look at it in another way:

It might be a good idea to keep the default REBOL vocabulary at a 
minimum and put extra functions (that people want for certain functionality) 
in includes.

Redefining system words:  It's an annoying problem. Geomol, and none 
of us is immune.

(I once debugged a CGI written by Carl. He'd used the info? mezzanine, 
but accidentally redefined the query word that it depends on. The 
results were wierd).
Namespaces should help.

I try to *not* clash with any words by always encapsulating code 
into objects -- so it's not 'query as global word, it's 'utilities/query
Meanwhile; the best we have is protect system.

what I have seen a lot through the years about people suggesting 
things (me included) on how to improve REBOL, is the tendency to 
ask for things from other languages.

many things are added to other languages, not because they are usefull, 
or where included by design.  but because the language eventually 
outgrew its original design or because new users request feature 
XYZ so many times it felt like a good idea to add it.