World: r3wp

Yeah and at less evals then yours.

head clear back tail is much faster than reverse remove reverse. 
All of that reversing is series copying, as is remove from the head 
of a series. If you don't need your function to copy, change reverse 
remove reverse to clear back tail.

See already hammering out better code by talking about it.

Yup :). Also, the return value of mine matters, as it does with DIRIZE, 
while yours is tossed. You wouldn't be able to use yours as a swap-in 
replacement for DIRIZE for non-dirs. Mine is a function, while yours 
is more of a procedure (making the Pascal distinction).

I wouldn't use mine at all for myself ;-)

I'm getting to where I use less and less mezzanines.

At least for the more simply things.

If you add a file on the end of the function you would have a useful 
return value. Then the only difference would be the copying.

My approach is to improve the mezzanines to the point where it actually 
makes sense to use them instead of optimizing them away, or at least 
to the point where their code is good enough to inline. If I don't 
use it in highly optimized code, it doesn't go in.

The simpler and faster I can make them the better. If this means 
imporovements to the natives to make the mezzanines better, then 
any code you write that also uses the natives will also be better. 
And you get good library funnctions too :)

;Just using remove


undirize: func [file [file! string! url!]][if #"/" = last file [remove 
back tail file] file]

We should profile to see which is faster: remove or clear.

The remove is better.

They are within variance of each other in this case. Interchangeable. 
After multiple runs, both get faster times than the other.

Which is weird, because REMOVE does more work than CLEAR, what with 
the refinement checking.

I think it is the amount of movement via the index that is time consuming 
for the other method.

That would be the same with both. Well, remove is easier to undeerstand 
than clear, so it's a good choice.

Clear might have a lot of underlying code for ports use as well which 
may be the reason why remove is better.

Nah, both are actions so there is no type-specific overhead that 
affects use with other types.

And I didn't fine remove to be better consistently. Clear won half 
the time with the same code.

I don't know.  That is why we profile.  ;-)

The remove is more CLEAR to understand.  Pun intended.

I ran a dozen profiles of each, and they were 50/50 on which was 
faster. That is well within the profiler variance.

I submitted a tweak to dp that improves the accuracy, but the profiler 
is too inconsistent to time differences this small well enough.

Well you definately want to make sure your profiler works.

It works for big differences well enough (based on my testing).

For instance, that /into proposal was based on huge differences picked 
up by the profiler. If implemented it could eventually lead to user-visible 
reductions in overhead. That's a big deal.

When profiling traversal operations, I have experienced skewed results.

Interesting. Examples?

Well, my get-block function is an example.  I used it on a series 
of block data and get different results that don't seem to jive with 
my expectations.

Some more complex reads actually resulted in better performance then 
less complex reads.

Are you talking about file access?

I had done a test where I read a small 5000 record file and compared 
to a 100000 record file and the 100000 record file proviled better 
performance than the smaller one.

After the file read.

Sounds like cache is a factor here.

http://www.tretbase.com/forum/viewtopic.php?f=8&t=30#p131

That function.

Cache is definately a factor in those type of operations.

Looks like parse could help with the speed, but it might be harder 
to get it right.

I started to go that route but started getting bad performance so 
I went this route utilizing find.

It was most likely an implementation detail as find I assume uses 
parse.

Nope. FIND is faster than PARSE, but PARSE is faster than FIND with 
WHILE.

And while is slower than until and foreach.  It gets complicated.

The trick is that it is harder to write and optimize parse code, 
so it can get really slow without you understanding why. The downside.

It gets complicated.

 It gets more complicated with R3, since R3 has made most of the previously 
 mezzanine loop functions native. This means that FORALL and FORSKIP 
 are faster than FOREACH in R3, while they are much slower in R2.

LOOP is still the fastest though :)

Paul, it looks like that ANY+ function has potential, with some tweaks.

Yeah, that is my hope that some of those spark some interests.  Feel 
free to add comments on the site as well or updates to the functions 
that you feel could be more beneficial.  The goal of that thread 
was really to open the discussion of mezzanines and how to improve 
them.

ALTME is not the best medium for that type of  effort.  The forum 
remains with some clean code and examples.

Don't forget to bring up the most general of your library functions 
that would get the most use in the Idioms group.