World: r3wp

I have my own versions of the series comparison funcs Max proposed 
on 27-Jan. My versions of SHORTEST and LONGEST take a block of series 
values, and return the given item by length. I don't use them much, 
but there are times they are nice to have.

Every refinement with an optional value should accept also a none! 
(implied ?)
eg.
sum: func [
    "Return the sum of two numbers."
    arg1 [number!] "first number"
    arg2 [number!] "second number"
    /times "multiply the result"
    amount [number! none!] "how many times"
][	; test argument, NOT refinement
    either amount [arg1 + arg2 * amount][arg1 + arg2]
	; or if not amount [amount: 1] arg1 + arg2 * amount
	; or amount: any [amount 1] arg1 + arg2 * amount
]
so it would be possible to do:
summed: sum/times 1 2 (something) ;also if (something) is none

and obviously also:
summed: sum 1 2

instead of:
summed: either (something) [sum/time 1 2 (something)][sum 1 2]

apply :sum [a b (something) c]

Where is the multiplication?

>> foo: func [/bar x] [either bar [x] [99]]
>> apply :foo [(2 < 4) 123]
== 123
>> apply :foo [(5 < 4) 123]
== 99

Sorry but you are flying too high for me. I am tring to rewrite my 
sum function using aplly but do not understand how it could be done.

you don't rewrite sum, you rewrite your call of sum

The question is to have a simple method of calling whatever function 
which accpets an optional argument without rewriting the code that 
calls it evry time.

first, you can already pass none! as value to refinment arguments.

second, instead of your above
summed: either (something) [sum/time 1 2 (something)][sum 1 2]
just use:
t: (something)
summed: apply :sum [1 2 t t]

instead of my above
summed: either (something) [sum/time 1 2 (something)][sum 1 2]
I wish I could use
summed: sum/times 1 2 (something) ;also if (something) is none

for every Rebol function and also for my own functions preferably 
without explicitly add none! as a required type.

And how would you pass NONE as a refinement argument value?

if you have
amount: any [ amount 1 ]
you don't have to have the either

Marco, we use quite often code like:

>> foo: func[/something][
[     either something [ 1 ][ 2 ]
[    ]
>> foo
== 2
>> foo/something
== 1
>>

Also isn't it better to let the authors of the functions decide if 
the functions are able to accept none! or not?

And finally, in your case, why you must use the refinement, when 
you don't use it?

my-sum: func[
	arg1 [integer!]
	arg2 [integer!]
	amount [none! integer!]
][
	arg1 + arg2 * any [amount 1]
]
>> my-sum 1 2 3
== 9
>> my-sum 1 2 none
== 3

in the foo function /something is a refinement and not an _optional_ 
refinement. In your my-sum function amount is not a refinment and 
my-sum 1 2 none == 3 is correct. What I am saying is that the extra 
none! adds polymorphism (but i have not investigated that too much 
so i could be mistaken), so you can write: sum 1 2 or sum 1 2 3 or 
sum 1 2 none without checking for none before calling the function.

Ehm, the nature of refinements is that they're optional

And you can't write SUM 1 2 without a refinement if you have an extra 
AMOUNT parameter. The number of parameters is fixed in REBOL. The 
way to have optional parameters is to use refinements (or a BLOCK! 
argument)

I don't see the benefit to the propsal at this point.