World: r3wp

Fair enough.  I'll avoid the expression in the library docs.

Ok, next one.  I'm thinking about quit/halt.  If a script is started 
from the console with do,  it should halt to the console right?  
If started from an icon click or a shell command it should quit? 
 Or do people mind just restarting up another REBOL console when 
an app quits on them?  Or other way round, an app started with an 
icon click should never halt, correct?

Started from console, and it should just halt. I get this wrong sometimes 
myself. It could be good to have an equal way of doing this, so please 
tell me, when you find a good way! Standards! (It should also work 
equally on all version of REBOL on all platforms.)

I'm using  system/options/script  - it is only set if a script is 
started up along with REBOL.  I was thinking of posting a   cease 
 idiom.   It is kind of a pain to do a script that quits, but on 
the other hand, I don't think that in the general case, a script 
started from an icon should ever halt, so quit seems to be a better 
'default'.

Inconvenience to coders doing console work but safer for users running 
scripts.

Would it work, if scripts always use QUIT, and then when in a console, 
we redefine QUIT like:
>> quit: :halt

I like that idea.  %user.r could check if system/options/script is 
set (maybe).

HALT is then only used in situations, where scripts should return 
to the console, nomatter if it was started from the console or the 
desktop.

I'd buy into that.  Now can someone wield a big enough stick? :)

what is the official definition of an action! ? I keep forgetting 
the difference between actions and natives.

If I remember correctly, an action is some kind of a wrapper, that 
can handle different datatypes. In practise, they work like a native.

for the user, it has no meaning to know the difference between natives 
and actions?

I don't think so. Someone explained actions in here some time ago, 
I think.

I found this quote: "action values are native code, just invoked 
through type-specific indirection"

mmm... okay :-)

Let's take an example. ADD is an action! It can be used with many 
datatypes. Two of them:
>> add 1 2
== 3
>> add 1 2x3
== 3x4

So ADD is probably an action because of the way, it's internally 
written. I've found, that many actions have to do with numbers. Try:
>> ? action!

yes, a lot of them also has "Returns TRUE..." in their help text

I don't think, the programmers have to worry about actions, and therefore 
you can say, they're confusing. Calling them all natives would be 
ok with me.

Most (all?) of the ones returning TRUE is the "...?" words. Then 
it might be strange, why not all "...?" words are actions. See:
>> ? "?"

well, value? is a native, because it only accepts word! ?

That some of them are functions can be explained (they're mezzanines). 
But some of them are natives, which is strange to me.

input? is also a native.

hmm.. script accepts multiple datatypes. I don't think it's about 
that. It's probably only about how it's implemented internally.

Can you find an action, that only take one type of data? :-)

the full quote from earlier:


action values are native code, just invoked through type-specific 
indirection. APPEND would likely be an action value because its implementation 
would be different for each type you are appending to.

I think it's purely an implementation issue. If APPEND in R3 was 
a native rather than an action, it would not be able to use as many 
types as arguments as it does.

and APPEND in R3 is an action, so Brian is right there.

LOL, so it's me that defines whether rebols are "programmers" or 
not? :)

indeed, difference between native and action is how it is implemented.

actions are implemented as "methods" for the datatypes. natives are 
more like normal C functions.

I'll write that in my blog post :-)

Has anyone ever written a version of clean-script.r that will (attempt 
to) pretty print at email safe 80 column limits?

Geomol;  The  quit: :halt works...as long as you are used to typing 
"q" to leave the console.  Otherwise you get stuck trying to actually 
quit.  I think there is more thinking...

Ok...is there a function that emulates the behaviour of flowing through 
a script?

Outter.r
rebol []


while [true] [print "calling inner" do %inner.r  print "called inner"]

Inner.r

rebol []

if confirm "Quit? " [quit]
if confirm "Halt? " [halt]
if confirm "Break? " [break/return 10]
print "Bottom of inner"


The only way I can get outter.r to continue the while loop is by 
answering No to all the prompts and flowing through.  I'm questing 
for a way to get out of a do'ed script without breaking outter and 
recoding the whole inner script to have it flow through.  I'd like 
to be able to use do and not launch or call.

Thanks gentlemen;  Found a solution.  catch and throw.
outter.r

while [true] [print "doing inner" catch [do %inner.r]  print "done 
inner"]

inner.r
rebol[]
if confirm "Throw? " [throw "some value"]
print "Bottom of inner"


And with /name, why I think I'll write spaghetti.r    Just kidding. 
 rebols don't cook spaghetti.

I don't know of a width-limited formatter, but it would be a good 
thing to have.

Gregg; I started mucking with it.  The first blaring implication 
is splitting comments...it means actually modifiying the source.

Yes, that's the first problem I see as well.

when doing a read/part http://www.somewhere.com500


does it really only read the first 500 bytes, or does the server 
deliver everything and REBOL just cuts it down to 500 bytes client 
side? it seems to take an equal amount of time to read 500 bytes 
and 100 kb.

it reads everything

really? What is that refinement there for then? :-) Well, it might 
be understandable - read in opposite to open just can't be so fine-grained 
...

it probably depends on the webserver, if it will deliver only part 
of the page or not.

IIRC I tested open/part and skip and it worked, but it was long time 
ago ...

R2's HTTP does not support that kind of things.

I'm so irritating happy today! :-D (You may not be able to say such 
in english, but it works in danish.)

it does? :-D

Ops, wrong channel, that should have been in the "Chat" group.

Oh my, I'm just irritating! :-)

Today I was thinking about REBOL paths and namespaces navigation 
"problem". I would like some clever persons 

here, to educate me a bit in that area. So far I think, that REBOL 
breaks on some path rules, of course it 

depends, upon what "philosophy" you provide as an explanation. So, 
I was thinking about 

namespaces/paths/context, as of a tree .... So, all words are defined 
in top (global) context = root, right? 

(excuse simplification). Then comes first question - how can be following 
valid?:

a: 5
b: context [print a]


My objection is, that from the point of  'b "node", there is no 'a. 
So, my explanation is:

1) in the case of directory, we would use ../a
2) or we should go via root reference - b: context [print /a]

3) we create "philosophical" rule, stating that global (top) context 
words are propagated to subsidiary nodes 
(contexts)


I don't mind case 3), if such rules are well defined, and it will 
come, once we switch to modules.


How did I came to think about above? I have somehow aesthetical issue 
with REBOL, when I look at e.g. scheme 

code in R2. It is full of awfull system/words/word references. I 
don't like it. What I would like to see is to 
have some abbreviations. I know that we can do e.g.:

_print: system/words/print


My question is, if we could have some more abstracted solution? Do 
you remember 'with keyword? I don't 

remember how it worked, but I would like to have some ability to 
"bind" particular word from existing context 
to actual context:

bind system/words node here, so that I don't need to use paths
 (kind of like when you create links in unix 
filesystem hierarchy ....


Of course, here we go - we could easily get some colision, e.g. if 
target context contains the same words. But 

maybe that could be somehow taken care for (I thought e.g. about 
automatic adding of underscores, e.g. _print, 
but that is not good solution).


Well, the thing is, that I am not actually even sure, what am I asking 
for :-) So, I would like to ask, if 

some REBOL gurus thought about such topics, or am I completly unrealistic 
here?

Thanks ...

Some thoughts:

Case 3) is like in object-orientated languages. You inherit words 
from parent context (object or class) and can use them right away 
without any further syntax.

You'll probably see system/words/word references in cases, where 
it is words that very like get reused/redefined. So it's typed like 
that to make sure, it's the system definition of the word, that is 
being used.

I'll give you, it's not the most pretty and easy to read. Maybe some 
use of BIND can avoid it.