World: r3wp

this is different, I got mails like this:

This is the Postfix program at host mail.rebol.net.

I'm sorry to have to inform you that your message could not be
be delivered to one or more recipients. It's attached below.

For further assistance, please send mail to <postmaster>

If you do so, please include this problem report. You can
delete your own text from the attached returned message.

			The Postfix program

hmm, there might be some misconfiguration on your provider's side, 
and hence your mail being regarded a spam for e.g.?

But I can see your messages on ml, so ...

fine, I hope you will post your preferences, then :-)

preferences to what? :-)

well,it is just that sometimes it happens, that mail server can be 
misconfigured, but it is not your case apparently, or my mozilla 
would mark your emails as possible spam ...

everything looks fine here ...

preferences to what? :-)
 - I meant your preferences to the FOUND? subject

found? select reduce [1 none] 1

and

    switch/default 1 reduce [1 none] [2]

(I hope you received that post)

yes, twice :-)

found? select 1 reduce [1 none] .... should be found? select reduce 
[1 none] 1 probably?

I like 'found? as-is, but it is true, that I sometimes thought, that 
it would perform 'find for me too .... found? find series value - 
simply that 'find is redundant here ....

but that is just my non-native english perspective, which came to 
my mind few times, without actually thinking more deeply about consequences 
...

as to found? select ... dunno if it is valid thinking - you are not 
searching the series, altough reading the expression "in english" 
might suggest it - you are performing found? on the result of select 
function call ....

right, Pekr, I mentioned the SELECT issue because it is "at the heart" 
of the SWITCH problem

Using found? select .. can be problem anyway as the selected value 
can be 'none (you found 'none) :-)) I'm not using found? much often 
i prefere none? and not none? (found? is a shortcut anyway)

(sorry I can see pekr founded this issue as well:-)

how about the SWITCH question?

>> to logic! select [a b 0] 'b
== false

aha, that doesn't look good either

This is also problematic

i got that bounce email after my last post today too.

maybe someone subscribed to the list is bouncing? although the error 
message refers to a mail loop.

select reduce [1 none] 1 is the same problem as pick reduce [none] 
1 and so on... the problem with switch can be considered a bug, however 
switch expects a block after the value so this is debatable.

i think, that since we have other ways to check for existence (find 
for select, or length? for pick), the behavior is still acceptable 
because useful in many cases.

of course, Ladislav's /default approach would probably be better.

(but can never solve the switch problem completely, because any value 
used as default could appear in the block  - you have to use find)

right, Gabriele, but SWITCH can be implemented using FIND, which 
would solve this issue

switch expects a block after the value so this is debatable.
 - how about switch/default 1 [1 #[none]] [2] then?

sorry, forget about it, I just want to say, that SWITCH doesn't check 
the value is followed by a block

yes, i agree it's a problem, it's just not a problem in practice 
:)

i'd actually implement switch using parse. i find it very useful 
to be able to specify multiple values for the same block.

i.e. switch val [2 4 6 ['even] 1 3 5 ['odd]]

that is what Cyphre wants too

a possible implementation:

switch1: func [
    "Selects a choice and evaluates what follows it."
    [throw]
    value "Value to search for."
    cases [block!] "Block of cases to search."
    /default case [block!] "Default case if no others are found."
    /local blk
][
	value: find cases value
	if value [value: find next value block!]
    either value [do first value] [if default [do case]]
]

it is slower than SWITCH due to "double search", though

I like that behaviour. I planned to write something similar for a 
long time... :)

Mmm.. parsing numbers...

How much effort is a switch in c?

switch2: func [

    "Selects a choice and evaluates the first block that follows it."
    [throw]
    value "Value to search for."
    cases [block!] "Block of cases to search."
    /default case [block!] "Default case if no others are found."
    /local rule
][
	rule: [
		1 1 () ; <-- value
		to block! set value block! (return do value) 
		to end
		| skip to () ; <-- type? value
	]
	rule/3: value
	change back tail rule type? value
	any [
		parse cases [some rule]
		do case
	]
]

;test
repeat n 10 [
	print [
		n

  switch2/default n [2 4 6 ['even] 1 3 5 ['odd]] [mold "--default--"]
	]
]
switch2 1 []
switch2/default 1 [] ["--default--"]

Actually, don't need to wrap the final two lines in the ANY block.

>> switch 1 [1 [2]]
== 2
>> switch1 1 [1 [2]]
== 2
>> switch2 1 [1 [2]]
** Throw Error: Return or exit not in function
** Where: switch2
** Near: return do value

fixing it right now...

I think it's fixed, but I'm also working on a version which evaluates 
the action block for every value and following block found.

That could be useful, allowing intersections of behaviours.

(and should not interfere with the usual usage we are used to.)

How about this:

switch2: func [

    "Selects a choice and evaluates the first block that follows it."
    [throw]
    value "Value to search for."
    cases [block!] "Block of cases to search."
    /default case [block!] "Default case if no others are found."
    /local rule
][
	rule: [
		1 1 () ; <-- value
		to block! set case block! ; <- re-use the 'case variable
		to end
		| skip to () ; <-- type? value
	]
	rule/3: value
	change back tail rule type? value
	parse cases [some rule]
	do case
]

{switch2: func [

    "Selects a choice and evaluates the first block that follows it. 
    This occurs for every matching value and following block found."
    [throw]
    value "Value to search for."
    cases [block!] "Block of cases to search."
    /default case [block!] "Default case if no others are found."
    /local rule
][
	rule: [
		1 1 () ; <-- value

  to block! set case block! (case: do case) ; <- re-use the 'case variable, 
  twice...
		| [skip to ()] ; <-- type? value
		| skip
	]
	rule/3: value
	rule/11/3: type? value
	any [
		all [
			parse cases [some rule]
			case
		]
		do case
	]
]}

;test
repeat n 10 [
	print [
		n

  switch2/default n [2 4 6 ['even] 1 3 5 ['odd]] [mold "--default--"]
	]
]
switch2 1 []
switch2/default 1 [] [probe "--default, ok--"]
switch2 1 [1 [probe "ok"]]
switch2 2 [1 [probe "bad"]]
switch2 1 [1 2 [probe "ok"]]
switch2 2 [1 2 [probe "ok"]]
switch2 3 [1 2 [probe "bad"]]

; multiple action blocks
switch2 1 [1 2 [probe "ok"] 1 3 4 [probe "ok#2"]] ; <-- 
switch2 2 [1 2 [probe "ok"] 1 3 4 [probe "bad"]]
switch2 3 [1 2 [probe "bad"] 1 3 4 [probe "ok"]]
switch2 4 [1 2 [probe "bad"] 1 3 4 [probe "ok"]]
switch2 5 [1 2 [probe "bad"] 1 3 4 [probe "bad"]]


switch2/default 5 [1 2 [probe "bad"] 1 3 4 [probe "bad"]] [probe 
"--default, ok--"]