World: r3wp

only usable for loading from strings, or with some caution IMHO.
  probe to-block mold/only %test/

Hi, is it possible to restore the date of a file which was read via 
ftp?

How about not using ftp and try Coyote :)

>> foo: [a [does this]]
== [a [does this]]
>> bar: [b [does that]]
== [b [does that]]
>> rejoin [foo bar]
== [a [does this] [b [does that]]]

Is there an equivelant function that would give me:
== [a [does this] b [does that]]

>> A: []
== []
>> insert A bar
== []
>> insert A foo
== [b [does that]]
>> ? A
A is a block of value: [a [does this] b [does that]]

Yep, I can fudge it that way, but I was looking for a single function, 
like 'rejoin or 'reduce

Or, if you don't mind changing 'bar:
>> insert bar foo
== [b [does that]]
>> ? bar
BAR is a block of value: [a [does this] b [does that]]

There probably is, but I prefer simpler commands so I know what's 
going on  (^.-)

ah

compose [(foo) (bar)]

How about...

>> foo: [a [does this]]
== [a [does this]]
>> bar: [b [does that]]
== [b [does that]]
>> append copy foo bar
== [a [does this] b [does that]]
>> compose [(foo) (bar)]
== [a [does this] b [does that]]

ugghhh I still needa get used to 'copy

No, specifically looking for -- word [foo bar]

I have a feeling that if 'reduce doesn't do it, then nothing will...

>> one-word: func [block /local val][val: copy [] foreach word block 
[append val get word]val]
>> one-word [foo bar]
== [a [does this] b [does that]]

;~>

I should have specified built-in...

Hehe, I expected that. ;~>

Although, I don't understand why.  It is a one-line solution so I 
don't see why it should make a difference if it is built in or not...

I was thinking (name pending) --

one-word: func [blk][head while [not tail? blk][blk: change/part 
blk get blk/1 1]]

I'm not partial to creating new values when I don't have to :^)

I think I like that better.

I think that this functionality should be added to GET

There are quite a few words in REBOL that, IMHO, should have automatic 
block handling.

Hmm, and I was thinking of a refinement to 'reduce.  'Get makes more 
sense...

... Is there a quick trick to compare 2 pairs??  Seems 'lesser? or 
greater? dont work on pairs...

Tell me, is 10x0 or 0x10 greater?

from my point of view its equal ;-)

Thansk for the wakeup call ;-)

Are you thinking about this?
>> data: 10x0
== 10x0
>> data/x
== 10
>> data/y
== 0
>>

I'd just compare X and Y values separately...

perhpas yes...

Yes thats what i do currently...

Are you trying to compare area?  -- greater-pair?: func [p1 p2 /local 
ps][ps: reduce [p1 p2] pick ps (p1/x * p1/y) > (p2/x * p2/y)] -- 
which can be tweaked for when p1 and p2 are equal...

Thanks Chris... i worked it out by splitting the pair into parts...

Chris:

>> foo: [a [does this]]
== [a [does this]]
>>  bar: [b [does that]]
== [b [does that]]
>> foobar: compose [(foo) (bar)]
== [a [does this] b [does that]]

ah, it's there already

Yes it is - but he wants [foo bar] to become  [a [does this] b [does 
that]] without the () or anything else inside..

I think the answer is: it's not in current rebol.

Yep, I'm resigned to that.  (and I'll word my queries a little better 
next time :^)

http://www.rebolforces.com/articles/pairs/

A nice one...

how does one find out the currrent secure level?

secure query

a nice 1x1...

writing my own faq

I hope this is useful for someone

REBOL []

rest: func [s [series!]][skip s 1]

define-object: func [
	spec [block!] 
	/local 

  arg-spec ctx-spec object-name constructor-name predicate-name attributes
		spec-rule type-spec continue? w
][
	arg-names: copy []

	continue?: [none] ;used to stop parsing
	name-rule: [set w word! (insert tail arg-names w)]

 type-rule: [set w word! (unless datatype? attempt [get w] [continue?: 
 [end skip]])]

 spec-rule: [name-rule some [name-rule opt [into [some [type-rule 
 continue?]]]]]

	if any [
		not parse spec spec-rule
		arg-names <> unique arg-names
	][
		make error! "invalid spec"
	]

    object-name: to-string first arg-names
	constructor-name: to-word join 'make- object-name
	predicate-name: to-word join first arg-names '?
	attributes: rest arg-names

	arg-spec: copy []
	foreach itm attributes [
		insert tail arg-spec reduce [
			to-word join itm '-value
			either block? w: select spec itm [w][[any-type!]]
		]
	]

	ctx-spec: copy []
	arg-names: extract arg-spec 2 1
	repeat i length? attributes [

  insert tail ctx-spec reduce [to-set-word attributes/:i to-get-word 
  arg-names/:i]
	]

	;create constructor function
	set constructor-name make function! 

  compose [(reform ["Makes a new" uppercase object-name "object with 
  attributes" mold attributes]) (arg-spec)]
		compose/only [make object! (ctx-spec)] ;body

	;create predicate function
	set predicate-name make function! 

  compose [(reform ["Determines if value is a" uppercase object-name 
  "object"]) value [object!] /local types]
		compose/deep/only [
			either (attributes) = rest first value [
				foreach itm (attributes) [
					unless any [

      [any-type!] = types: select (arg-spec) to-word join itm '-value
						find types type?/word value/:itm
					][return false]
				]
				true
			][
				false
			]
		] 
]

With it you can create objects that are type checked when constructed.

;; usage
define-object [name attribute1 [datatype1 ...] ...]
;; creates two functions
make-name
name?

;; example untyped
define-object [point x y]
point? probe o: make-point 1 2
point? probe o: context [x: 1 y: "two"]

;; example typed
define-object [point x [integer!] y [integer!]]
point? probe o: make-point 1 2
point? probe o: context [x: 1 y: "two"]