Jamis Buck jgb3@email.byu.edu wrote in message news:401F1E82.1080008@email.byu.edu…
ts wrote:
“P” == Phil Tomson ptkwt@aracnet.com writes:
Yes, I figured that it was being interpreted that way, but my question is
why?
ruby use `…’ for the range operator and the flip-flop operator.
Reading the posts in this discussion has been very enlightening for me.
I finally understand the flip-flop operator, for one thing. And I think
I understand the root of the “dislike” some people have for the
flip-flop: it uses the same syntax as a completely unrelated (and
possibly more common) concept, which can make the intuitive leap a bit hard.
I can certainly see the value in the flip-flop, and where I was
originally on the “team” that was rooting for its removal, I now would
like to see it remain, but in different form. What if it used a
different syntax, but the same semantics? This would allow the
flip-flop to be used outside of conditionals, too, since there would be
no ambiguity involved.
So, instead of ‘…’ and ‘…’, how about something completely new, like
perhaps ‘–’, or ‘~~’? Or even a new keyword, like ‘flip’ or
‘flipflop’? It would be nice to also somehow provide a way to access
some underlying objectified represention of the flip-flop, so that its
state could be queried and manipulated,
– would look too much like decrement (from the perspective of other
languages) so that could also be confusing. ~~ might be better.
‘flipflop’ is the object, not the action and in this case it seems
like you’re basically trying to say:
“do something from the time condition A becomes true until the time
condition B becomes true”. Perhaps, as you say, a new keyword is in
order. But what if we could make use of an existing keyword; I’m
thinking that ‘until’ might work. It would look something like:
if l=~/BEGIN/ until l=~/END/ do
#do something in this range
end
Actually, I don’t think ‘until’ is really a keyword (correct me if I’m
wrong), but that it’s actually a buit-in method that takes a block, so
it might be difficult to coerce it into this proposed usage.
Another idea would be to have a ‘from (condition) to (condition)’
statement that looks looks like:
from l=~/BEGIN/ to l=~/END/ do
#do something in this range
end
Then we just need some way to determine if the range is inclusive or
exclusive…
from l=~/BEGIN/ to l=~/END/ inclusive do
puts l
end
#prints:
BEGIN
foo
bar
END
from l=~/BEGIN/ to l=~/END/ exclusive do
puts l
end
#prints:
foo
bar
…but maybe there’s a better way to do that. Also, how do you get
the same kind of behavioral differences that we see with the current
… and … flip flop operators?
It seems like the ‘from (condition) to (condition)’ statement could
also return the underlying flip/flop object, kind of like returns
an Array or {} returns a Hash. So there could still be a FlipFlop
class, but this would just be a shortcut that keeps you from having to
instantiate a FlipFlop object explicitly prior to use.
ff = from l=~/BEGIN/ to l=~/END/ { … }
OR:
from l=~/BEGIN/ to l=~/END/ {|ff| … }
then you could call methods on the ff object, like:
ff.status? (true or false)
ff.class #=> FlipFlop
I’m just sort of brainstorming here, but I think the ‘from … to …
{}’ statement is very readable and the intent is quite clear and it
just might be able to replace the current flipflop operators.
Phil