World: r3wp

Ladislav, Petr: It is all right to use ME for puzzles though, time 
permitting :)

I just wanted to give you the opportunity to write it, because I 
knew you were thinking about it,...

Is there a way to read the dates when a file was created? I'd like 
to add a "newest" file choice to one of my apps. Thanks.

James:
probe info? %rebol.exe

creation, not modified? depends on os. look for get-modes.

Thank you. How you all know this stuff amazes me! Again thanks.

We are all role-players, and after some years of trying alll doors.. 
;)

Yeah, I see what you mean. It takes that kind of person. I just keep 
on staying in the same room until I give up and ask for the "cheat 
code."

The difference between 'real programmers' , language junkies and 
us newbies.  I fall into your category as well James.

On Windows:
>> get-modes %rebol.exe 'file-modes

== [creation-date access-date modification-date owner-write archived 
hidden system]
>> get-modes %rebol.exe 'creation-date
== 19-Aug-2003/11:21:03+10:00

newbies/hobbyists

I ask for cheatcodes immediate. There are enough doors left anyway.. 
;)

Style/functionality question: I'm writing a function to deal with 
adding to block a block with [Title Content [(Childs if exists)]].

Childs are not required - is it better to add [Title Content] (if 
no childs) or to provide empty block - [Title Content []]?

Support both by setting a default value of an empty block in your 
code, perhaps like this:
childs: any [pick data 3 []]

Pick returns none if out of range, so any will move on to the next 
expression, your default value.

If you need to change the childs block, remember to use  make block! 
0  or  copy []  instead of  [] .

Yes, i know that.

My question is more "philosophical" - what is better by experience.

As for now, I think that providing empty block will be more "compact"

It's better to be forgiving in your dialects - it leads to fewer 
syntax errors.

be forgiving
 - what do you mean?

brb

From a philisophical standpoint, it is best to be somewhat forgiving 
in your evaluation of the syntax of data that is input to your function, 
but exact in the syntax of the data that is ouput from your function. 
That will make sure that the effect of errors or flexibility in the 
data is limited to the code that is doing the initial evaluation. 
This means that if you can figure out from context what a default 
value is, do so, and then your function will be more usable, particularly 
when the data may be written by hand.

Thanks Brian :)

It's sort of like the stated philosophy of Unix command line utilities.

this should be in core

 cls: does [ print "^(1B)[J" ]

I am creating some variables dynamically

so, they are .. "formvar1" .. "formvarn"

how do I unset them?

unset[ formvar1]

>> var1: does [ print "hello" ]
>> var: join "var" 1
== "var1"

so, given 'var, how do I unset var1 ?

>> unset to-word var

ahh...

that seems to work.

While reviewing the action! functions, I noticed the path action. 
The doc comment says "Path selection.". The parameters aren't typed. 
Does anyone know what this action does, and how to use it? Or whether 
it can be called directly at all?

what are action values anyway?

imean, where are they documented?

help action!

it only  list all the action! values. hey you are just bluffing! 
:)

btw, ive seen u invited to the french translation task. im heavily 
trying to learn rebgui, so u as well can use a nice editor for the 
qtask lang file ;)

path seems to be a "clear find". Do not know about uses.

but it keeps the length

it pokes an 'unset! there. mold then stops.

yeah, i saw

and fucks it up somehow, because if i change the unset!  to something, 
the path still stays in a strange state

I could repair it with a/4: 12

maybe could be used to exclude something from mold? To stop this 
recursive things?

could u show me w an example what mold are u talkin about?

OneTom, actions are how type-specific operations are implemented 
in REBOL. Every datatype has a table of function pointers, one pointer 
for every action. Every one of those tables are layed out the same, 
with the function corresponding to the same index being the version 
of the same function for that specific type. Each action! has an 
index associated with it - you can see the index like this:

>> second :add
== 1


When the action! is called, REBOL checks the datatype of the first 
argument to it and then calls the function at that index into the 
datatype's table. This is the way that REBOL implements polymorphic 
native functions, single dispatch on the datatype.


But really, you don't need to know any of this. All you need to know 
is that an action! is like a native!, but with a differently named 
datatype.

!> a: [b 1 c 2 d 3]
== [b 1 c 2 d 3]
!> path a 'c
!> a
== [b 1 c]
!> length? a
== 6
!> a/4: 12
== 12
!> a
== [b 1 c 12 d 3]

:)) it still makes me feel a lot happier knowing all these background 
info, brianh! thank you for clarifying this

Its a good idea to know about it. Seems its possible to path action! 
to protocol. at least i made a 'find in a  protocol once and got 
all the refinements.