World: r3wp

What's wrong here ?

rebol [
]

write %tryme.pdf
dirlist: read %//

foreach myfile dirlist [
	if find myfile ".pdf" [
		print ["Filename" myfile]
		extension: find/last/tail myfile "."
		print ["EXT" extension]
		print extension = "pdf"
	]
]
delete %tryme.pdf
halt


The comparison extension = pdf should return TRUE, instead I have 
FALSE

try 

suffix? myfile

%.pdf = suffix? myfile

I have found the function but I wish to know why te comparison fails

because myfile is of type file!, and so extension is also file!

try

print extension = %.pdf

Ok, understood. The fact I am able to start a "find" on it let me 
think it is a string...

This belongs in rebol school group

O:-)

BrianH wants to keep this group to discuss 2.7.8

I'll move there :-)

Back on pair comparisons, MIN and MAX don't return one of the given 
pair values (not sure if someone else mentioned that).

>> max 10x11 9x12
== 10x12

? 
max 10 9  = 10
max 11 12 = 12

you get the area which encloses both

And back in the Core group - we're trying to keep this group on its 
topic of R2 releases. We don't want to lose such discussions in the 
middle of discussions of semantics. The only reason this group was 
created is because some of the people working on the development 
of R2 don't want to use chat yet. This group is *only* a replacement 
for the R2-Beta world.

using MIN on offsets and MAX on size you get the enclosing box


when you use MAX on offsets and MIN on size you get the intersection 
of both boxes

I think Gregg was posting this as a bug.

This is not the R2 equivalent of the !REBOL3 group. Please don't 
abuse the fact that we can't move messages in AltME :(

I'm sorry, I don't want to be a jerk about this. This group is used 
as a reference when we do new R2 releases. It's of less value as 
a reference if off-topic stuff is overwhelming the release discussions. 
Please be nice to the R2 release manager :(

sorry to add junk, but I *really* think this group should be renamed 
(this is On Topic :-)  

probably !REBOL2-release or something like that.


its too easy to mistake right now with !REBOL3 being such an active 
group.

Requested.

Done.

Thanks :)

If I want to set something to the index of a series, or something 
else if it's not there I have to do this

b: either a: find series var [
	index? a
][ 	default ]

when I'd rather do

 b: any [ index? find series var default ]

So how about letting index? also take none as an argument ?

b: any [ attempt [ index? find series var ] default ]

funny thing is, that the former code is exactly as long as the latter 
one, does not need the additional variable, and it is faster

...and I find it more readable

yep, no need for additional var.

all [b: find series var b: index? b]

oups, not what you'he done

indeed, I just meant:

b: either b: find series var [index? b] [default]

I'm pretty sure I'd be ok with  NONE == INDEX? NONE

That kind of change is not going into R2 - it's not backwards-compatible. 
Try R3.

But it's easy enough to create a safe INDEX? function. I think Gabriele 
calls his INDEX?? and I borrowed it from him.

that's another issue .. how to easily redefine words

that also invoke the original word ....

index?: func [  [ series! | none! ]
][
	either series [ index? series ][
		none
	]
]

would likely cause a stqack overflow

[ series! none! ]

Gregg, I don't remember that, so maybe it was from someone else.

Gregg, the problem is that the changed INDEX? would have the possibility 
of returning data that is not an integer. Most R2 code doesn't screen 
for that, so changing INDEX? in this way would lead to data corruption 
in existing code. Remember, compatibility with existing code is the 
highest priority in the further development of R2. Incompatible changes 
are reserved for R3 *only* - we try to not make them in R2, on principle.

Defining a new function with a different name is a good way around 
that problem :)

Or, adding a refinement

Adding refinements to low-level natives can double their overhead 
for each refinement - more for mezzanines. Not a good idea.

So, how can we redefine old words without causing a stack overflow?

Current r2 code would be using an error handler to see if index? 
threw an error ... not a biggie

Use a local reference to the old function, then call through the 
reference. You can do this with a private variable, or composing 
the code block of the new function to have a direct reference to 
the old function value. That last method can be awkward with functions 
called with refinements, but it can be done; the private variable 
metod is less awkward.

example?

Yes, but current R2 code would be depending on that error to trigger 
the code in the error handler, rather than just propagating the error 
to where it would do more damage. Error handling code is there for 
a reason.

use [idx?] [
idx?: :index?
index?: func [series [ series! | none! ]] [
	either series [ idx? series ][none]
]
]

that looks untested to me

You wanted an example. I just converted your code to a style that 
wouldn't have a stack overflow.

The | was in your original code :)