[ruby-core:44263] [ruby-trunk - Feature #3845][Rejected] "in" infix operator

Issue #3845 has been updated by matz (Yukihiro Matsumoto).

Description updated
Status changed from Assigned to Rejected

This proposal is only for cosmetics.
I don't want a new operator that does not introduce something new.

Matz.

----------------------------------------
Feature #3845: "in" infix operator
https://bugs.ruby-lang.org/issues/3845#change-25800

Author: mame (Yusuke Endoh)
Status: Rejected
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: 
Target version: 


=begin
 Hi,
 
 I'd propose "in" infix operator.
 
 (<arg> in <args>) yields true when <arg> is included in <arg>.
 Otherwise it yields false.
 
 
   p "found"     if 1 in 1, 2, 3  #=> found
   p "not found" if 0 in 1, 2, 3  #=> not found
 
 
 "in" operator is clearer to the reader than Array#include?:
 
   p "found"     if [1, 2, 3].include?(1)
   p "not found" if [1, 2, 3].include?(0)
 
 
 This proposal is similar to Object#in? proposed in [ruby-core:23543].
 But there are two differences:
 
   - "in" operator does not pollute name space of Object class
 
   - each candidate of "in" is evaluated lazily; for example,
 
       1 in 1, 2, foo()
 
     does not call the method "foo" because 1 is found before that.
 
 
 Note that this proposal ensures the syntax compatibility, since
 "in" is already a keyword for "for" statement.  But "for" statement
 is rarely used.  This proposal utilizes the rarely-used keyword.
 
 
 I wrote an experimental patch.  It implements the operator as a
 syntactic sugar to "case" statement:
 
   <arg> in <args>
     =>  (case <arg>; when <args>; true; else false; end)
 
 The patch causes no parser conflict.
 
 
 One more thing.  The following expression is rejected:
 
   foo(x in 1, 2, 3)
 
 This is because it is ambiguous; this expression can be interpreted
 as three ways:
 
   foo((x in 1), 2, 3)
   foo((x in 1, 2), 3)
   foo((x in 1, 2, 3))
 
 You need write parentheses explicitly.
 
 
 What do you think?
 
 
 diff --git a/parse.y b/parse.y
 index e085088..64318bd 100644
 --- a/parse.y
 +++ b/parse.y
 @@ -745,6 +745,7 @@ static void token_info_pop(struct parser_params*, const char *token);
  %nonassoc  modifier_if modifier_unless modifier_while modifier_until
  %left  keyword_or keyword_and
  %right keyword_not
 +%nonassoc keyword_in
  %nonassoc keyword_defined
  %right '=' tOP_ASGN
  %left modifier_rescue
 @@ -1258,6 +1259,14 @@ expr		: command_call
  			$$ = dispatch2(unary, ripper_id2sym('!'), $2);
  		    %*/
  		    }
 +		| expr keyword_in args
 +		    {
 +		    /*%%%*/
 +			$$ = NEW_CASE($1, NEW_WHEN($3, NEW_TRUE(), NEW_FALSE()));
 +		    /*%
 +			$$ = dispatch2(in, $1, $3);
 +		    %*/
 +		    }
  		| arg
  		;
  
 diff --git a/test/ripper/test_parser_events.rb b/test/ripper/test_parser_events.rb
 index 5d76941..6005457 100644
 --- a/test/ripper/test_parser_events.rb
 +++ b/test/ripper/test_parser_events.rb
 @@ -1107,4 +1107,8 @@ class TestRipper::ParserEvents < Test::Unit::TestCase
      parse('/', :compile_error) {|msg| compile_error = msg}
      assert_equal("unterminated regexp meets end of file", compile_error)
    end
 +
 +  def test_in
 +    assert_equal("[in(1,[1,2,3])]", parse('1 in 1, 2, 3'))
 +  end
  end if ripper_test
 
 -- 
 Yusuke Endoh <[e-mail]>
=end



-- 
http://bugs.ruby-lang.org/