World: r3wp

That is how I do also Henrik, I would be interested in a better solution 
but I was thinking we need one to handle the blocks within blocks

the only other way in R2 is to process each block one by one with 
a loop

I can build the function to loop through a block looking for others 
but am curious about the effect on bindings.

I think we made a 'flatten function once.

good name

Tell me more about in what way you think the bindings will get lost.

with FORM you always lose bindings

try searching for flatten in AltME. plenty of references to it, I 
can see here.

But I can only think that bindings would be lost for those blocks 
assigned as a value to a word

Seems it would still be useful for data taken from a stream of string 
data

I can't calculate in my head when exactly the bindings are lost, 
so I would suggest simply experimenting in the console.

Yeah I definately think that would be the case for set-words that 
contain block values but should be no problem on passing block data 
to set-words that are currently not set.

flatten: func [blk [block!] /local res rule value] [
    	res: copy []

     rule: [some [into rule | set value skip (append res :value)]]
    	parse blk rule
    	res
    ]

Here is a function for when you just want part of the block's flattened 
for when you reduce a bunch of data and want to use select on the 
data:

semi-flat: func [blk /local blk2][
    while [not tail? blk][
        if block? blk/1 [
            blk2: copy blk/1
            insert remove blk blk2
            blk: next next blk
        ]
    ]
    blk: head blk
]

>> data: [[1 ["record1"]] [2 ["record2"]] [3 ["record3"]]]
== [[1 ["record1"]] [2 ["record2"]] [3 ["record3"]]]
>> semi-flat data
== [1 ["record1"] 2 ["record2"] 3 ["record3"]]
>> select data 2
== ["record2"]
>> select data 3
== ["record3"]

Paul, you can avoid copy blk/1 by using change/part.

And perhaps better to continue processing the data when blk/1 is 
not a block.

semi-flat: func [blk][
    while [not tail? blk][
        blk: either block? blk/1 [
            change/part blk blk/1 1
        ][
	    next blk
	]
    ]
    head blk
]

semi-flat [[1 ["one"]] [2 ["two"]] "other data"]

You can also use until instead of while:
semi-flat: func [blk][
    until [
	tail? blk: either block? blk/1 [
            change/part blk blk/1 1
        ][
	    next blk
	]
    ]
    head blk
]

Yes Anton, thanks.

Anton, both of those functions you provided didn't seem to achieve 
what I was intending to do which was to format the block for easy 
selecting using 'select.

My example data contains "other data" which is probably confusing 
you, sorry.

Anyone know what the discussions are regarding extending the alias 
function in REBOL3?  I have a bit ugly function that does something 
like that now.  What I'm talking about is the ability to alias for 
example find/only or find/case or instead of just find so that no 
refinement has to be supplied.  I submitted a wish for this some 
time ago and hoped it would make it in REBOL3 but don't know what 
is intended regarding that.

I checked the alpha and noticed that it still says it doesn't allow 
path! for its word argument.

Probably should move this question to R3 group

Gregg, thanks I will look into the ICS method.

I have a script that sends out a newsletter to several hundred people. 
Sometimes (often) the mail server will disconnect before all the 
emails are sent. What is the best way to make the script reconnect 
and continue sending?

Here is a little function I made to handle a situation I often find 
myself in.  Say you got three words and want to do something if one 
of the words has a value other than false or none.  But you may want 
to do something else if two words have a true value or maybe all 
three and then if also if none have a value such as a default.  This 
is a very flexible function I created to allow you to do that:

evals: func [blk blk2 /local r i l][
    r: 0
    i: 0
    l: length? blk2: reverse blk2
    foreach item blk [if get item [r: r + (2 ** i)] i: i + 1]
    while [l > 0][
        if r > (2 ** (l - 3)) [return first blk2]
        blk2: next blk2
        l: l - 1
    ]
    last blk2: head blk2
]

Now say you have some locals in a function that you want to check 
for any combination of them being used.  The evals function will 
let you do that.

the 'blk argument would be the locals (assuming that 'evals is a 
subfunction of  our function) that you want to pass to the evals 
function and the 'blk2 would be what to return if those values are 
true.  So for example, if I have the following locals in my function:

/any /only  


and say I have a default value of "default" that I want to return 
if /any or /only is not used.  Therefore, I pass the following:

evals [any only]["default" "any" "only" "any and only"]


it would then process the result.  This can be a very handy function.

>> any: true
== true
>> only: true
== true
>> evals [any only]["default" "any" "only" "any&only"]
== "any&only"

>> any: false
== false
>> only: true
== true
>> evals [any only]["default" "any" "only" "any&only"]
== "only"

>> any: false
== false
>> only: none
== none
>> evals [any only]["default" "any" "only" "any&only"]
== "default"

Pretty cool, eh?

the function shouldn't be used on more than three values just yet 
as I need to work on it a bit more to get it just right - I keep 
overlooking something.

ahhh I didn't subtract the values

This is probably more practical:

evals: func [blk blk2 /local i r ][
    r: i: 0
    foreach item blk [if get item [r: r + (2 ** i)] i: i + 1]
    return select blk2 to-integer r
    select blk2 0
]

then you just supply the second block with the desired options you 
want combined.

Request for code (in any language) that correctly identifies leap 
years. Anyone want to do the inevitable one-liner?
http://leapyearday.com/hr/freecode.html

Diy: func [year][either not equal? mod year 4 0 [return 365][ either 
equal? mod year 100 mod year 400 [return 366 ][return 365]]]

wrong

Diy: func [year][either not equal? mod year 4 0 [return 365][ either 
equal? zero? mod year 400 not zero? mod year 100 [return 365 ][return 
366]]]
should work

Leap?: func [Y][return not not any [(Y // 400 = 0) all [(Y // 4 = 
0)  (Y // 100 <> 0)]]]

("not not" for changing 'none into 'false)

I think, this works too:

diy: func [y][either y // 4 = 0 [either all [y // 100 = 0 y // 400 
<> 0] [365] [366]] [365]]

Here's my contribution....It may not be as fast as others, but it 
relies on REBOL's inbuilt definition of a leap year, so no need to 
duplicate logic:

leap?: func [date [date!] ][

  return not error? try [print 1 to-date rejoin ["29-02-" date/year]]


Seems to work on all border cases: 1899 --> 1904 ... 1999 --> 2004
  ]

Sunanda, that's an interesting approach! :-)

The diy would then be:

diy: func [y] [either error? try [to-date join "29-02-" y] [365] 
[366]]
:-) REBOL is wonderful!

Does anyone send emails to them?