World: r3wp

I'm going to have to use a loop :(

I don't know why subtract does not work on blocks

foreach el set2 [ remove find set1 el ]

I tried yours and it didn't seem to work... but this definitely does:

c: 0
blk:  [ 1 2 3 1 2 3 1 4 ]

unique remove-each i copy blk [ c: c + 1 not find (at blk c + 1) 
i]

I can't see why mine won't work ...

since set2 is a unique version of set1, it will always find and always 
remove

I've long considered + and - on blocks to be useful... but, would 
others agree?

YES!

go for it!

though I don't mind if we use 'subtract and 'add

They're the same.

there is also a really usefull missing "set" function


duplicates:   returns items in a series present multiple times in 
that series.


without this function, right now there are many missing combinations.

to get singletons:

exclude blk duplicates block

next you'll be asking for the ability to create combinations and 
permutations!

well, AFAIK duplicates is probably the single most frequently re-requested 
series function I've seen in the years.

so return those in a block where there exists more than one?

yep.

which is essentially what I was trying to do above

what instances have you needed this?

but its so usefull in simplifying many other loops and algorithms.

when managing data sets, you often want to know what is unique "within" 
that set.   

duplicates and singletons are often-required things you want to know 
about a data set.

i guess make a wish on curecode for R3

yes... I just thought about that.

I will.

Has anyone a simple algorithm for calculating the last day of a month? 
 Or is a lookup table easiest?


get-end-month: func [ d [date!] /local tmp ][ tmp: d while [ tmp/month 
= d/month ][ tmp: tmp + 1 ] tmp ]

get-end-month: func [ d [date!] /local tmp ][ tmp: d while [ tmp/month 
= d/month ][ tmp: tmp + 1 ] tmp - 1 ]

get-end-month: func [ d [date!] /local tmp ][ tmp: d  tmp/day: 28 
while [ tmp/month = d/month ][ tmp: tmp + 1 ] tmp - 1 ]

set 'last-day-of-month func [date /local d] [
    d: date
    d/day: 1
    d/month: d/month + 1
    d: d - 1
    d
]

nice

>> append [] 'now/precise
== [now precise]

is there a better way?

Is this better? To get an unevaluated now/precise into a block:
    append [] [now/precise]

possibly...

found a different way, so won't be needed.

I wanted a nice way to produce fragmented message strings that will 
be translated later, using a TRANSLATE function. So I made this function:

tell: func [blk /local out s] [
	out: make string! 10000
	parse blk [
		any [
			[
				set s string! (append out translate s)

    | to any-type! copy code [to string! | to end] (append out to string! 
    reduce [#"'" mold/only do code #"'"])
			]
			(append out #" ")
		]
	]
	join trim out #"."
]

>> file: what-dir
== %/c/program files/rebol/view/

>> tell ["File" file "cannot be found"]
== {File '%/c/program files/rebol/view/' cannot be found.}

>> append/only [] 'now/precise
== [now/precise]

interesting, thanks

Henrik, I don't think that's nice, because you can't really translate 
"File" and "cannot be found" separately. Don't expect all languages 
to have the same grammar structure etc.

Gabriele, probably not, but the language system, I'm working with 
works like this.

a better one would probably input the string like:

File %1% cannot be found.

Maybe I should do that...

What I did for the network detective was "File <file> cannot be found." 
See SUBSTITUTE in http://www.colellachiara.com/soft/libs/utility.r

ok, thanks

(I think that <filename> or %filename% etc. helps the translator 
a lot more than %1% or anything like that. Of course, Qtask uses 
%1%. :-)

how do you determine the order without referring to the tag twice?

ok, I see what you're doing....

Anyone got a suggestion on how to flatten the results of a SQL query.
Got [ [ "xxx" ] [ "yyy" ] [ "zzz" ]]
and want 
[ "xxx" "yyy" "zzzY ]

now
to-block form [ [ "xxx" ] [ "yyy" ] [ "zzz" ]]

does not work ... due to Rebol evaluating the contents

sure I could iterate over the whole lot and create a new block ...

>> collect [foreach item [["xxx"] ["yyy"] ["zzz"]] [keep item]]  
   
== ["xxx" "yyy" "zzz"]

Even simpler:
>> map-each item [["xxx"] ["yyy"] ["zzz"]] [first item]
== ["xxx" "yyy" "zzz"]

heh .. not used map-each or collect before .. are these in R2 ?