World: r3wp

And I must say it again... I use ATTEMPT only in cases where I do 
not expect error. Many people use it just a shortcut for error? try 
which I don't lik. As I understand attempt as higher function for 
reporting not wanted errors (for example on server). If you use it 
in cases, where like attempt [to-integer "a"] it's not good as it 
would report many errors (in some bigger context)

And Henrik, I don't think Carl will add it into Rebol as it's too 
easy to implement yourself.

Oldes, probably not, though this is just one case. A more complex 
datatype like date! requires more complex checking schemes.

And I would not use it, as I usually use something like this:
if error? try [a: to integer! a][a: 0]

And date! does not behave like integer!:

>> a: 1
== 1
>> b: "2"
== "2"
>> c: "u"
== "u"
>> to-date reduce [a b c]
** Script Error: Invalid argument: 2
** Where: to-date
** Near: to date! :value

This is probably a dumb case since endusers don't determine the types 
themselves.

and if I would use it, I would probably use it like:
to-date?: func[a][ not error? try [a: to date! a]]

can the to function translate to user defined structures / objects 
? if  so how, is there a special method name in the object you want 
to convert to ?

If I understand your question, Charles, you may be looking for construct/with......It's 
a way of using an existing object as a template for a new one, eg:
 my-obj1: make object! [a: 99 b: 2 c: "string"]
my-obj2: construct/with  [b: 9999] my-obj

hmm... is it possible to find () elements in a block? they don't 
have a specific datatype.

find [a b c (code) d] ?? ; what type?

Is this a start?
 find [a b c (code) d] paren!

ah, precisely, thanks. didn't know there was a type for them

because:

type? () == unset!

And, perhaps worse:
    type? (1)
    == integer!

which is not what you might expect..... You have to do this to get 
type? to work:
     type? first [(1)]
    == paren!

The parens! triger evaluation so type? (1) = type? 1 ;== integer!

But parens inside blocks are not evaluated.

Is there a way to find out if a loaded file is encrypted with CLOAK?

Or do I have to read it and try to DECLOAK it?

As far as I know, an encloaked string is just a jumbled up, binary 
version of the original string: it carries no prefix signature so 
you can't tell at a glance it is an encloaked string rather than 
another bit of binary.

So, yes, as far as I knoww, you'll have to read and attempt decloaking. 
 Or, if you have control over the writing, ensure some sort of identifiable 
prefix is added)

>> do to-path reduce ['now 'none]   
** Script Error: now/none has no refinement called none
** Near: do to-path reduce ['now 'none]
>> do to-path reduce ['now none] 
== 25-Feb-2007/20:40:18+1:00
>> do probe to-path reduce ['now none]
now/none
== 25-Feb-2007/20:40:28+1:00
>> now/none
** Script Error: now has no refinement called none
** Near: now/none


I guess the difference is between 'none and none!, but I thought 
it was curious that the none! is accepted as a refinement.

>> now/#[none!]
== 26-Feb-2007/14:28:03+11:00

Actually it looks like you can put any issue!
>> now/#hello
== 26-Feb-2007/14:28:43+11:00

functions just ignore anything that is not a word in the path.

DECLOAK: I have the problem that a random char is added as the first 
char to a decloaked string. Is this a known problem?

Not to me it isn't. What version of rebol ?

It's not in Rambo.

encloak / decloak seem pretty stable to me. Be aware that these functions 
modify the string you pass it.

I only have the problem when not using read/binary but just have 
used WRITE and READ... strange.

Just don't use just WRITE with encloked data as these data are binary 
data.

I've never had a problem with encloak/decloak, but I would also avoid 
string ops that might translate the binary data somehow.

Yes, READ and WRITE are in text mode and translate line terminators, 
so LF can become CRLF and vice versa.

Is there any better way how to convert issue! to binary! than this 
silly one?

issue-to-binary: func[clr ][load head insert tail insert next mold 
clr "{" "}"]

and what do you want... the string or the value?

I want binary value

so four byte issue gives 32 bite value...

or is initial issue a decimal type integer?

>> issue-to-binary #ff0000
== #{FF0000}

at this moment as-binary is working like:
>> as-binary #ff0000
== #{666630303030}

which i really don't like

I know... both are valid .

same for tuples, etc.

for going to-from hex... I don't have a solution.

it's stupid behaviuor. I really don't know what it can be good for, 
as I can always do:
>> as-binary next mold #ff0000
== #{666630303030}

ech, I know why it's molded as string - issue can hold any value... 
:( so my Rambo wish is pretty stupid now:-)

issue-to-binary: func[clr] [debase/base as-string clr 16]

issue-to-binary: func[clr] [debase/base clr 16]

YES :-) that's much more better, thanks.

oldes, do you want me to delete that ticket or should i keep it?

yes please

delete it as it's a nonsense