World: r3wp

I'm OK with coming in second here, as long as user-defined types 
can include function types :)

Carl - maybe we could just rename May plan to the June one? It came 
late and imo if you were supposed to write new one, it would not 
be much different, or would it?

Maxim - you are so long here remembering R1? :-)

reduci: func ["Example of reduce using DO/next" blk] [
	out: make block! 3
	forskip blk 0 [append/only out do/next blk 'blk]
	out
]

Please, a new June plan that also recaps the May accomplishments 
:)

Maxim, I haven't been here that long - just got here for the release 
of R2, though I did use R1 for one project.

I remember eagerly waiting for view  :-)

The View alpha/beta list was fun :)

It was called Ally, and I still have it archived :-)

Sterling Newton, Jeff Kreis, Holger Kruse, Jim Goodnow - RT was big 
company back then :-)

the thing I miss most is reading about REBOL on every tech news site 
on the net every other week.

well, we are so small, that we don't even update rebolweek properly. 
It will be more difficult to get noticed once again, as we missed 
some momentum, but it can be done. Done by example, by some work 
- e.g. posting news to OSNews.com etc., or wrapping something like 
Google Wave, showing the world JS UI is still slow crap :-)

and the helpfull and always generous support that Bo would give out

Shouldn't do/next not allocating new block be called do/next/into 
instead of coming with other tricks?

No, the /into option doesn't work like that. The /next word could 
be named cont, since it is a kind of continuation :)

I would really rather have the non-block-allocating DO/next, even 
if it isn't consistent with LOAD/next or TRANSCODE/next. DO of block 
is lower-level than those two, in terms of overhead.

However, if we want to change LOAD/next to match it's an easy fix.

'do/next - I use it in a function as a subverted version of 'case. 
 Perhaps if that's a bad function, there is an alternate way to implement 
it?

We are implementing it in the alternate way already :)

Oh, you meant your subverted (?) CASE, not DO/next. CASE itself is 
very good, and we use it extensively.

rebol/next ?

Carl > Have you seen wave.google.com ? 

why isn't that kind of project  made with  Rebol ?
 

I mean most of the technologies involved in wave could be done using 
rebol and even in a better way if  instead of jave/python xml and 
html you can design a wave oriented dialect . Your clever than me 
so I think you already got the point.

next ask is do you think  somthing like colaborative "at the same 
time" could be possible to do with R3  for example hum lets be crazy 
in futur viva-rebol IDE offers a way to make several ppl working 
on the same project at the same time use the viva-rebol IDE and sharing 
in real time information

for example you and me works on the same file at the same time using 
viva-rebol ide and you fill a part of the file i fill another part 
of the file and we both see in real time what the other is doing. 

(for example you do the parse parse rules and i write the GUI  of 
an applicaton things like that)

well that's not a new thing Moon edit propose that kind of collaboration 
real time since some years already. what i like in wave is the modular 
aspect  you are not limited to a conversation you can create  "wavelets" 
to anykind of  use and extrapolating that system to the already existing 
rebol tools (rebol.org, view/desktop, ios etc...) would be really 
a big thing

B: does block if case is false.  Sort of like 'all, but with a reason 
for each failing case (provisionally called 'assert-all):

either assert-all [
	case-a [raise "Case A failed"]
	case-b [raise "Case B failed"]
	0 < 1 [raise "Something is very wrong"]
][
	print "Both Cases were true!"
][
	probe raised-val
]


Makes more sense when each case is dependent on the previous one, 
for validating input, etc.

All cases were true!
 - I added one : )

Might be easier to do with parens instead of do/next, but the case-like 
construct is more readable...

Take a look at the ASSERT function in R3 - it might do what you need 
faster and safer. Or it might be off-topic :(

Never mind, I read a point above incorrectly.

Another attempt (I don't give up yet :-) - has anyone problem, if 
money! datatype would be renamed to unit! datatype? I think "money" 
is really a bad name for something being more general and precise...

Yes, I have a problem with it, due not being able to identify money 
during parsing, if we lose it. I think there should be more focus 
on having a generic BCD number type. As money is now, I think it 
should be left alone, but add other datatypes that are more appropriate 
to specific jobs.

Some ppl still confuse what I am proposing. The same goes for Carl. 
I don't want to remove anything. I just want to change the really 
bad name. I refuse to accept the fact, that such general mechanism 
as BCD is linked to as ugly name as money! is. So what I want is 
- either another general BCD datatype, or - rename money! to unit! 
and it could work that way:

g$100
v$100
km$100
USD$100

Of course I am not sure it is flexible enough, as how would I express 
e.g. km/h?

Calling it "money" makes sense when you consider that the only available 
character for the literal representation is $.

renaming it sounds very much like removing it.

I have to be really stupid, or I really can't understand, how renaming 
something = removing something? So are we going to remove 'map, just 
because we are going to rename it to 'map-each?

also tieing a unit to a number directly might limit the applicability 
of unit calculations as used in physics and symbolic math.

I don't want to call it "unit!" because the type would be really 
poor for that, and we don't want to reserve the word "unit" for a 
poor implementation of the idea, especially when we have user-defined 
datatypes.

BrianH: then think of $ as a sign of measure (that was another name 
for money, but unit is shorter and more to the point). Why is file 
represented by % sign then? It has nothing in common with percentage 
= $ has nothing in common with money. Maybe in US.

Pekr, renaming a function is not the same as renaming a datatype. 
You lose functionality and gain something specifically different. 
When renaming a function, you don't lose anything.

File is being represented by % since that is what was left.

Henrik - how can you loose functionality by just renaming it? :-)

Pekr, you don't have money anymore. That's the loss.

And it's important to have as many datatypes as possible for dialects.

I know. I just thought, that money (better let's call it currency), 
is just another unit ...

$ is used as a sigil of money in many countries, not just the US.

OK, so give me BCD! type then. I will not do make money! just because 
I want some precision. That reads badly ...

IIRC there was a blog what to do with money! datatype, and if the 
datatype should be more "complex". That is still not resolved.

In school, units were always encased in [], such as 5 [m / s]. I 
think it's possible to do something similar in REBOL.