World: r3wp

I just think that 'SINGLE? will hardly ever be used, as it doesn't 
fit well with the naming of all other series handlers.


if LAST? where there, I think we'd use it naturally.  since it fits 
it with TAIL? LAST FIRST, etc.

I'll CC it.

Suggest both alternatives: Renaming it, or making an alias.

Carl suggested SINGLE? - he uses it (presumably).

but he might not have tought of LAST?   sometimes these little things 
escape us, since we implement this or that within a current "frame 
of mind" ;-)

The change would need to be backported to 2.7.8, so we need a ticket.

CC ticket added,  #1636

In fact, I suggested SINGLE? (see R3 chat #4330) and Carl took it 
up immediately. I use SINGLE? a lot.

not saying single be removed... its just like   empty? and tail? 
  they have different semantic meanings, but in rebol are equal in 
implementation.

...more or less :)

Good suggestion, Henrik :)

as I stated in the ticket, 'LAST? should be none tolerant, whereas 
'SINGLE?  could stay strict as it is.

hum...  I thought ordinal functions had become none safe in R3?

>> first none
** Script error: cannot use pick on none! value
** Where: first
** Near: first none

(this is in A96)

No, they are bounds safe. We want FIRST none to trigger an error.

Originally I thought, that the FUNCT function was quite adventurous 
doing a deep search for set-words. But, after using it a couple of 
times, it really looks like it does what is useful most of the time.

saves time ..

FUNCT is very nice. I love it.

I wonder if we can do the same for use ... uset

CONTEXT would be close.

@Graham: context [...] is not enough?

Hmm.. could work :)

so what advantage is there for  use [ ] [ ... ] as opposed to context 
[ ] ?

use doesn't return an object, so its overhead is less I guess.

and you can specify a list of words, thus being entirely independent 
of the code inside.

So, you can define a global variable without using set 'xxx = yyy.

Here is my benchmarks:

benchmark [use [a b c d] [a: 1 b: "xyz" c: 3 d: a * c]] ; == 0:00:01.094
benchmark [context [a: 1 b: "xyz" c: 3 d: a * c]] ; ==0:00:01.484
my benchmark function runs the block 1.000.000 times.

interesting

benchmark: func [b][s: now/precise loop 1000000 [do b] difference 
now/precise s]

miniscule difference

I should use this for my web pages ...

I get different results
>> benchmark [context [a: 1 b: "xyz" c: 3 d: a * c]]
== 0:00:01.455
>> benchmark [use [a b c d] [a: 1 b: "xyz" c: 3 d: a * c]]
== 0:00:03.753

strange..
>>  benchmark [context [a: 1 b: "xyz" c: 3 d: a * c]]
== 0:00:01.468
>> benchmark [context [a: 1 b: "xyz" c: 3 d: a * c]]
== 0:00:01.469
>> benchmark [context [a: 1 b: "xyz" c: 3 d: a * c]]
== 0:00:01.469
>> benchmark [context [a: 1 b: "xyz" c: 3 d: a * c]]
== 0:00:01.5
>> benchmark [use [a b c d] [a: 1 b: "xyz" c: 3 d: a * c]]
== 0:00:01.093
>> benchmark [use [a b c d] [a: 1 b: "xyz" c: 3 d: a * c]]
== 0:00:01.094
>> benchmark [use [a b c d] [a: 1 b: "xyz" c: 3 d: a * c]]
== 0:00:01.094
>> benchmark [use [a b c d] [a: 1 b: "xyz" c: 3 d: a * c]]
== 0:00:01.094

@sqlab: try to bigger value.

>> benchmark [context [a: 1 b: "xyzdddddddd" c: 3 d: a * c]]
== 0:00:14.423


>> benchmark [use [a b c d] [a: 1 b: "xyzdddddddd" c: 3 d: a * c]]
== 0:00:37.302

very strange.. I guess it's because of OS, hardware etc.
>> benchmark [context [a: 1 b: "xyz" c: 3 d: a * c]]
== 0:00:15.048
>> benchmark [use [a b c d] [a: 1 b: "xyz" c: 3 d: a * c]]
== 0:00:11.11
for 10.000.000 times.

Endo, the thing is much simpler than that. I bet, that you are using 
R2

ofcourse :)

then, read the name of this group

That explains it.

oh, yes, sorry, I just wanted to reply Grahams question..

so, use and context are really different in R3.

USE is a wrapper around a closure!. CONTEXT creates an object. Very 
different.

USE is mezzanine in R3 - source it.

Sure, I would think that USE would be faster than CONTEXT (as in 
R2) but it is not.

USE is just a helper function in R3. We use modules as the primary 
structuring model now.

Or objects.

Now if you created the closure yourself ahead of time, instead of 
creating a new closure every time (as USE does) then it would be 
faster.

Can you show how?

blah: closure [a b c d] [a: 1 b: "xyzdddddddd" c: 3 d: a * c]
benchmark [apply :blah []]

HTML of new R3 doc pages has similar problems on most pages due to 
no urlencode of ampersand in urls and invald <th> declarations using 
old <tr> attrib values for vertical-align in a <th> element.  I would 
gladly fix ad hoc and you can fix your page gen tools (?) later