World: r3wp

My problem is that I forgot many things because I haven't done them 
in so long.  Plus I forget what changes were made so I find myself 
doing something complicated that has now been simplified.

I rarely use FALSE actively, more relying on that many functions 
like ALL and ANY work best with NONE. This shortens many functions.

potential?: func [arg][all [word? :arg not lit-word? :arg]]

However, I think the function would work better like:

potential?: func [arg][all [any-word? :arg not lit-word? :arg]]

Yeah I just threw it out there as I had it in the console at the 
moment but feel like it could be of benefit to have it built into 
R3 as a mezz or something.

Your functions are returning none so I don't think we want that.

;Mabye this:


potential?: func [arg][if all [any-word? :arg not lit-word? :arg][return 
true] false]

Seems to work ok:

>> blk: [print "print" 'print]
== [print "print" 'print]
>> potential? blk/1
== true
>> potential? blk/2
== false
>> potential? blk/3
== false

potential?: func [arg][found? all [any-word? :arg not lit-word? :arg]]


blk: [print 'print "print"] print potential? blk/1 print potential? 
blk/2 print potential? blk/3
true
false
false

... just to be part of the game ;-)

There you go Ingo!

I forgot about found.

Just when I was starting to think there was no longer a use for it.

I admit, I had to look it up, too.

lol - I kept thinking in my head what I can return this back with 
that would explicitly evaluate to true or false and not give none 
but you FOUND it - pun intended.

So does anyone else think potential? should be a mezz function?  
If so, what should the name of it be proposed as?

I'm not sure it's needed often enough to warrant its inclusion, first 
take at a name: 

non-lit-word?

But it that really doesn't give an indication of what the function 
is for which I believe the function is for is to find if an argument 
has a potential to be evaluate

Your functions are returning none so I don't think we want that.

 <-- my point was that NONE can be more useful than FALSE and gives 
 simpler code, if you are not using NONE as a specific value.

Can you provide an example Henrik?

I gave it above. Simplified code.

Yeah but that is a trade off to useability in my opinion.  For example 
I can say pick [this that] potential? arg

true, if you need to do that.

but what if you don't? :-)

I think we will have to do that more than the situation where we 
would desire it to return none is why I mention it.

ok, then ignore my suggestion :-)

I didn't ignore it - I just want to make sure if we propose it then 
it meets the highest amount of usability.  I'm interested in all 
ideas.

Sorry, just going nuts ...

able-to-have-a-valus?

or in short:

valuable?

valus? = value? of course ...

I like valuable?

Ingo, do I have your ok to submit your form of the valuable? function 
via Rambo?

Anyone know why the case function has a /all refinement?  Seems the 
/all is what case does by default.

Sure you have my OK.

I see a difference ...


>> case/all [1 probe 1 2 probe 2 3 probe 3 false probe false 5 probe 
5]  
1
2
3
5
== true

>> case [1 probe 1 2 probe 2 3 probe 3 false probe false 5 probe 
5]      
1
== 1

Bye, I'll leave for now.

Yeah I am confused by the wording as it says for the /all:

Evaluate all cases

and for the function itself:

Evaluates each condition

That sounds the same.

case will normally stop after the first true condition.  case/all 
will evaluate all of the true conditions.

The key bit from the HELP is REFINEMENTS:
     /all -- Evaluate all cases (do not stop at first true case)

Yeah I understand how it works but the help documentation seems confusing.

would be nice to also break out of one of evaluated cases.

There is always a REBOL way  :)  And after I post this, someone else 
will come by with the real answer.
 

>> print catch [case/all [true [print 1] true [print 2] true [throw 
"4"] true [5]]]

that will work btiffin.

That seems rather clean also.

How about the following wording for case? 


Evaluates conditions until the first is true, then evaluates what 
follows it.

Makes it sound a bit like the first condition must be true.

Evaluates each condition until true, then evaulates what follows 
it.

Then again that one makes it sound like all conditions must be true.

Evaulates conditions until a condition is true, then evaluates what 
follows it.

That sounds less confusing.

Evaluates conditions until a condition is true, then evaluates the 
associated value.