World: r3wp

We can safely assume that you are talking about R3 when proposing 
that behavior be changed, since R2 is in compatibility mode.

Anyone know a simple way to transform a block of sub-blocks into 
a single block while retaining the original type? I have [ [1] [2] 
[3]] and I'd like [ 1 2 3]. I can do with with form and parse but 
it  then I get ["1" "2" "3"].

result: copy [] foreach x [[1 2]] [3 4] [5 6]] [append result x]

>> blk: [[1][2][3]]
>> forall blk [change blk blk/1]
>> blk
== [1 2 3]

My version can only copy with subblocks of length 1.

copy = cope

Maybe better:
forall blk [change/part blk blk/1 1]

Slight differences - no internal blocks are preserved in Geomol's:
>> blk: [1 [2] [3 [4]] [5 6]]    
== [1 [2] [3 [4]] [5 6]]
>> forall blk [change/part blk blk/1 1]                     
== []
>> blk
== [1 2 3 4 5 6]


My version (gives the same result as kcollins, but is in-place like 
Geomol's) only flattens one level:
>> blk: [1 [2] [3 [4]] [5 6]]          
== [1 [2] [3 [4]] [5 6]]
>> forall blk [blk: back insert blk also blk/1 remove blk]
== [6]
>> blk
== [1 2 3 [4] 5 6]

>> to-block form [ [ 1 [ 2] 3 ] [ 4] ]
== [1 2 3 4]

Another, from the 'parse school:

	parse block [
		any [block: any-block! (insert block take block) :block | skip]
	] head block

this should be a native in R3... there are MANY places where this 
is both needed and its always slow.

I've got some gui code which I am loading from a text string, and 
then running it.  I am binding it to some local words which I want 
to use and that works fine.

But I also want to invoke functions in the global context and it 
can't find them.  What to do?

eg. the text is

button "test" [ alert "hello" ]

and I get an error clicking on the button.

Bind the loaded text to a global word first ('system ?) then to your 
local context.

So, here, how would I get this working?


test: func [ /local lo ][ lo:  {button "test" [ alert "hello" ]} 
view layout to-block lo ]

test: func [ /local lo ][ lo:  {button "test" [ alert "hello" ]} 
view layout bind to-block lo 'all]

Let me try that ...

Just don't use 'all in your local context.

currently I am binding the block to some local words in the context

Bind to 'all first, then your local word(s)

eg ...

this is user written gui code which is why I bind to the local context 
to prevent them doing stuff that I think might be dangerous.  But 
I want to allow some exceptions.

Assign the global functions to local words:

context compose [alert: (:alert)]

this doesn't work ...


 test: func [ /local lo alert] compose/deep [alert: (:alert) dummy: 
 none lo:  {button "test" [ alert "hello" ]} view layout bind to-block 
 lo 'dummy]

dummy should be local too

Yeah, not sure why - do you get "alert has no value" ?

** Script Error: alert word has no context
** Where: func [face value][alert "hello"]
** Near: alert "hello"

do-protected: use [alert][
	alert: get in system/words 'alert
	func [txt][do bind to-block txt 'alert]
]

do-protected {alert "Foo"}
do-protected {print "Foo"}

So in theory it works, next how to apply to your function.

Not working in my function yet.

this works 


test: func [ /local lo alert dummy] compose/deep [alert: get in system/words 
'alert dummy: none lo:  {button "test" [ alert "hello" ]}    view 
layout bind to-block lo 'dummy ]

just not working in my script though

oh .. remove the compose/deep

Hmm, try this:

isolate: func [words [block!]][
	use words compose/only [
		set (copy words) forall words [change/only words get words/1]
		first (copy words)
	]
]


do-protected: func [txt allowed][do bind to-block txt isolate allowed]

do-protected {print "foo"} [print]
do-protected {alert "foo"} [print]

'isolate takes a block of words, creates an exclusive context, sets 
words in that context to their value in their current context and 
returns a word bound to that context.

In your code above, allowed is not a block of works

some nice css - html expansion macros http://www.smashingmagazine.com/2009/11/21/zen-coding-a-new-way-to-write-html-code/

A quick look at it - reminded me a little of Henrik's HTML Dialect

I bet the guy who wrote that also likes regexp. :-)

Any easy way to detect whether running 32 or 64 bit windows?

On WinXP 32bit:
>> get-env "ProgramFiles(x86)"
== none
On Win7 64bit:
>> get-env "ProgramFiles(x86)"
== "C:\Program Files (x86)"

Really, any non-none string value returned will signal 64bit.

cool

I have one question .. I don't want somebody to surprise me tomorrow 
on talk about rebol... if you use the "with" pattern for example 
for pop protocol

with-pop-do: func [ mbox addr code ] [ 
    set :mbox open addr
    do code
    close get :mbox
]

with-pop-do 'box get-pop-addr [
    pages: "something"
]

and define a variable/word "pages" in the block like I did .. this 
word changes the global binding probably? which is not very good 
because it might owerride some other binding ... am I correct and 
is there some elegant way to not introduce such negatiev side of 
this otherwise elegant pattern?

Something like this?

use [pages] [
	with-pop-do 'box get-pop-addr [
		pages: "something"
	]
]

aha.. interesting.. I never knew what use does

I could also use "use" in definition of with-pop-do so that the external 
code is most beautifull

thanks a lot