e$B$^$D$b$He(B e$B$f$-$R$m$G$9e(B
In message “Re: [ruby-dev:30893] Re: block wrapper”
on Tue, 5 Jun 2007 13:05:58 +0900, Tanaka A. [email protected]
writes:
|> e$B$3$l$O;d$NJ}$G:n6H$7$^$9!#:#$9$0La$;$k$J$i?tF|Cf$K!"e(BYARVe$B%3%"e(B
|> e$B$G$NBP1~$,I,MW$J$iBP1~8e$9$0$KLa$7$^$9!#e(B
|
|e$B?tF|$O$?$C$?$H;W$$$^$9$,!“2?$+LdBj$,$”$j$^$7$?$+e(B?
e$B:n6H$9$k;~4V$,<h$l$J$$$H$$$&LdBj$,e(B…e$B!#e(B
e$B$9$$$^$;$s!"!:@Z$H@o$C$F$$$^$9!#e(B
In article E1HtJVx-0005m3-Sg@x31,
Yukihiro M. [email protected] writes:
|e$B$"$H!"0JA0e(B yield *v e$B$Ge(B wrapper e$B$,F0$+$J$/$J$C$?;~$K$^$D$b$He(B
|e$B$5$s$,e(B pp.rb e$B$rJQ$($?$N$O85$KLa$7$F$$$?$@$1$^$;$s$+e(B?e$B$3$l$O;d$NJ}$G:n6H$7$^$9!#:#$9$0La$;$k$J$i?tF|Cf$K!"e(BYARVe$B%3%"e(B
e$B$G$NBP1~$,I,MW$J$iBP1~8e$9$0$KLa$7$^$9!#e(B
e$B?tF|$O$?$C$?$H;W$$$^$9$,!“2?$+LdBj$,$”$j$^$7$?$+e(B?
e$B$^$D$b$He(B e$B$f$-$R$m$G$9e(B
In message “Re: [ruby-dev:30894] Re: block wrapper”
on Tue, 5 Jun 2007 14:36:43 +0900, Yukihiro M.
[email protected] writes:
||> e$B$3$l$O;d$NJ}$G:n6H$7$^$9!#:#$9$0La$;$k$J$i?tF|Cf$K!"e(BYARVe$B%3%“e(B
||> e$B$G$NBP1~$,I,MW$J$iBP1~8e$9$0$KLa$7$^$9!#e(B
||
||e$B?tF|$O$?$C$?$H;W$$$^$9$,!“2?$+LdBj$,$”$j$^$7$?$+e(B?
|
|e$B:n6H$9$k;~4V$,<h$l$J$$$H$$$&LdBj$,e(B…e$B!#e(B
|e$B$9$$$^$;$s!”!:@Z$H@o$C$F$$$^$9!#e(B
e$B$H;W$C$?$N$G$9$,!“8=<BF(Hr$K$A$g$C$H:n6H$7$?$i$”$C$H$$$&4V$Ge(B
e$B$7$?!#LdBj$O$"$j$^$;$s$G$7$?$N$GLa$7$^$9!#e(B
In article [email protected],
Tanaka A. [email protected] writes:
e$B$3$3$G5?Ld$,$"$k$N$G$9$,!"e(Byield e$B$re(B e$B8=:_$Ne(B 1.9 e$B$Ne(B b.call e$B$NF0e(B
e$B:n$K$7$F$7$^$o$J$$$N$O$J$s$G$G$7$g$&e(B?e$BJV;v$rBT$C$F$$$k$s$G$9$,!"$J$s$G$J$s$G$7$g$&e(B?
e$B$d$O$j5?Ld$G!“$H$F$bCN$j$?$$$N$G$9$,!”$J$s$G$J$s$G$7$g$&e(B?
e$B$I$3$K$3$@$o$j$,$“$k$N$+$o$+$i$J$$$N$G5$$KF~$k$+$I$&$+$O$o$+e(B
e$B$i$J$$$N$G$9$,!”;d$H$7$F$O<!$N$h$&$K$7$?$i$$$$$N$G$O$J$$$+$He(B
e$B;W$C$F$$$^$9!#e(B
e$B$I$&$G$7$g$&$+e(B?
e$B$=$7$F!"$3$NJQ99$r9T$($P!"e(Bpp.rb e$B$NJQ99$r85$KLa$;$^$9$7!"e(B
test-all e$B$G<:GT$7$F$$$ke(B drb e$B$J$I$N$$$/$D$+$N<:GT$,@.8y$9$k$he(B
e$B$&$K$J$j$^$9!#e(B
RCS file: /src/ruby/eval.c,v
retrieving revision 1.947
diff -u -p -r1.947 eval.c
— eval.c 23 Sep 2006 21:29:47 -0000 1.947
+++ eval.c 26 Sep 2006 16:52:04 -0000
@@ -223,7 +223,7 @@ static int volatile freebsd_clear_carry_
VALUE rb_cProc;
VALUE rb_cBinding;
static VALUE proc_alloc(VALUE,struct BLOCK*,int);
-static VALUE proc_invoke(VALUE,VALUE,VALUE,VALUE,int);
+static VALUE proc_invoke(VALUE,VALUE,VALUE,VALUE);
static VALUE proc_lambda(void);
static VALUE rb_f_binding(VALUE);
static void rb_f_END(void);
@@ -1065,6 +1065,7 @@ typedef enum calling_scope {
static VALUE rb_call(VALUE,VALUE,ID,int,const VALUE*,struct
BLOCK*,calling_scope_t,int);
static VALUE module_setup(VALUE,NODE*);
+static VALUE massign_args(VALUE,NODE*,VALUE,int);
static VALUE massign(VALUE,NODE*,VALUE,int);
static void assign(VALUE,NODE*,VALUE,int);
static int formal_assign(VALUE, NODE*, int, const VALUE*, VALUE*);
@@ -2594,7 +2595,7 @@ call_trace_func(rb_event_t event, NODE *
id?ID2SYM(id):Qnil,
self ? rb_f_binding(self) : Qnil,
klass?klass:Qnil),
Qundef, 0, 0);
Qundef, 0);
result = Qundef; /* no arg */
result = rb_ary_new2(0); /* no arg */
static VALUE
-rb_yield_0(VALUE val, VALUE self, VALUE klass /* OK /, int flags)
+rb_yield_0(VALUE args, VALUE self, VALUE klass / OK */, int flags)
{
NODE *node, *var;
volatile VALUE result = Qnil;
@@ -4689,7 +4690,7 @@ rb_yield_0(VALUE val, VALUE self, VALUE
int old_vmode;
struct FRAME frame;
NODE *cnode = ruby_current_node;
int lambda;
int state, broken = 0;
rb_need_block();
@@ -4723,37 +4724,26 @@ rb_yield_0(VALUE val, VALUE self, VALUE
node = block->body;
var = block->var;
lambda = block->flags & BLOCK_LAMBDA;
if (lambda && val != Qundef) {
if (TYPE(val) != T_ARRAY) {
rb_raise(rb_eArgError, "wrong number of arguments (1 for 0)");
}
else if (RARRAY_LEN(val) != 0) {
if (lambda) {
if (RARRAY_LEN(args) != 0) {
rb_raise(rb_eArgError, "wrong number of arguments (%ld for 0)",
RARRAY_LEN(val));
RARRAY_LEN(args));
}
}
}
else if (var == (NODE*)2) {
if (TYPE(val) == T_ARRAY && RARRAY_LEN(val) != 0) {
rb_raise(rb_eArgError, "wrong number of arguments (%ld for 0)",
RARRAY_LEN(val));
}
}
else if (!bvar && nd_type(var) == NODE_BLOCK_PASS) {
bvar = var->nd_body;
var = var->nd_args;
goto block_var;
}
else if (nd_type(var) == NODE_ARGS) {
if (!ary_args) val = svalue_to_avalue(val);
formal_assign(self, var, RARRAY_LEN(val), RARRAY_PTR(val), 0);
formal_assign(self, var, RARRAY_LEN(args), RARRAY_PTR(args), 0);
}
else if (nd_type(var) == NODE_BLOCK) {
if (var->nd_next) {
@@ -4763,25 +4753,19 @@ rb_yield_0(VALUE val, VALUE self, VALUE
goto block_var;
}
else if (nd_type(var) == NODE_MASGN) {
massign(self, var, val, lambda);
massign_args(self, var, args, lambda);
}
else {
if (lambda) {
if (val == Qundef) {
rb_raise(rb_eArgError, "wrong number of arguments (0 for 1)");
}
if (TYPE(val) == T_ARRAY && RARRAY_LEN(val) != 1) {
if (RARRAY_LEN(args) != 1) {
rb_raise(rb_eArgError, "wrong number of arguments (%ld for 1)",
RARRAY_LEN(val));
RARRAY_LEN(args));
}
}
if (ary_args) {
if (RARRAY_LEN(val) == 0)
val = Qnil;
else
val = RARRAY_PTR(val)[0];
}
assign(self, var, val, lambda);
if (RARRAY_LEN(args) == 0)
assign(self, var, Qnil, lambda);
else
assign(self, var, rb_ary_entry(args, 0), lambda);
}
if (bvar) {
struct BLOCK *b = ruby_frame->prev->prev->block;
@@ -4799,11 +4783,11 @@ rb_yield_0(VALUE val, VALUE self, VALUE
POP_TAG();
if (state) goto pop_state;
}
(!node || nd_type(node) != NODE_IFUNC ||
(!node || (nd_type(node) != NODE_IFUNC && nd_type(node) !=
NODE_IFUNC1) ||
node->nd_cfnc != bmcall)) {
rb_raise(rb_eArgError, “wrong number of arguments (%ld for 0)”,
RARRAY_LEN(val));
RARRAY_LEN(args));
if (node->nd_state == YIELD_FUNC_AVALUE) {
val = svalue_to_avalue(val);
}
else {
if (val == Qundef && node->nd_state != YIELD_FUNC_SVALUE)
val = Qnil;
}
result = (*node->nd_cfnc)(val, node->nd_tval, self);
result = (*node->nd_cfnc)(args, node->nd_tval, self);
}
else if (nd_type(node) == NODE_IFUNC1 && RARRAY_LEN(args)
== 1) {
result = (*node->nd_cfnc)(rb_ary_entry(args, 0),
node->nd_tval, self);
}
else {
result = (*node->nd_cfnc)(val, node->nd_tval, self);
result = (*node->nd_cfnc)(args, node->nd_tval, self);
}
return rb_yield_0(rb_ary_new2(0), 0, 0, 0);
return rb_yield_0(rb_ary_new3(1, val), 0, 0, 0);
}
VALUE
@@ -4922,7 +4905,7 @@ rb_yield_values(int n, …)
VALUE val;
if (n == 0) {
+VALUE
+rb_yield_splat(VALUE val)
+{
rb_raise(rb_eArgError, "not an array");
/*
loop {|| block }
@@ -4951,59 +4944,71 @@ static VALUE
rb_f_loop(void)
{
for (;
{
static VALUE
-massign(VALUE self, NODE *node, VALUE val, int pcall)
+massign_args(VALUE self, NODE *node, VALUE args, int lambda)
+{
return massign(self, node, args, lambda);
return massign(self, node, args, lambda);
return massign(self, node, args, lambda);
return massign(self, node, rb_ary_entry(args, 0), lambda);
+static VALUE
+massign(VALUE self, NODE *node, VALUE val, int lambda)
{
NODE *list;
VALUE args;
if (val == Qundef) {
args = rb_ary_new2(0);
argv = &val;
len = (val == Qundef) ? 0 : 1;
args = rb_ary_new3(1, val);
argv = RARRAY_PTR(tmp);
len = RARRAY_LEN(tmp);
args = tmp;
assign(self, node->nd_args, rb_ary_new4(len-i, argv+i), pcall);
assign(self, node->nd_args, rb_ary_new4(RARRAY_LEN(args)-i,
RARRAY_PTR(args)+i), lambda);
}
else {
assign(self, node->nd_args, rb_ary_new2(0), pcall);
assign(self, node->nd_args, rb_ary_new2(0), lambda);
else if (lambda && i < RARRAY_LEN(args)) {
goto arg_error;
}
while (list) {
i++;
static void
-assign(VALUE self, NODE *lhs, VALUE val, int pcall)
+assign(VALUE self, NODE *lhs, VALUE val, int lambda)
{
ruby_current_node = lhs;
if (val == Qundef) {
@@ -5068,7 +5073,7 @@ assign(VALUE self, NODE *lhs, VALUE val,
break;
case NODE_MASGN:
massign(self, lhs, val, lambda);
break;
case NODE_CALL:
@@ -5115,7 +5120,7 @@ assign(VALUE self, NODE *lhs, VALUE val,
}
cnt = lhs->nd_head->nd_alen;
if (RARRAY_LEN(val) < cnt) {
if (pcall) {
if (lambda) {
rb_raise(rb_eArgError, "wrong number of arguments");
}
else {
@@ -5144,11 +5149,11 @@ assign(VALUE self, NODE *lhs, VALUE val,
}
VALUE
-rb_iterate(VALUE (*it_proc)(VALUE), VALUE data1, VALUE
(*bl_proc)(ANYARGS), VALUE data2)
+rb_iterate_0(enum node_type functype, VALUE (*it_proc)(VALUE), VALUE
data1, VALUE (*bl_proc)(ANYARGS), VALUE data2)
{
int state;
volatile VALUE retval = Qnil;
NODE *node = NEW_NODE(functype, bl_proc, data2, 0);
VALUE self = ruby_top_self;
PUSH_TAG(PROT_LOOP);
@@ -5180,6 +5185,18 @@ rb_iterate(VALUE (*it_proc)(VALUE), VALU
return retval;
}
+VALUE
+rb_iterate_splat(VALUE (*it_proc)(VALUE), VALUE data1, VALUE
(*bl_proc)(ANYARGS), VALUE data2)
+{
+VALUE
+rb_iterate(VALUE (*it_proc)(VALUE), VALUE data1, VALUE
(*bl_proc)(ANYARGS), VALUE data2)
+{
struct iter_method_arg {
VALUE obj;
ID mid;
@@ -5198,6 +5215,18 @@ iterate_method(VALUE obj)
}
VALUE
+rb_block_call_splat(VALUE obj, ID mid, int argc, VALUE *argv, VALUE
(*bl_proc)(ANYARGS), VALUE data2)
+{
+VALUE
rb_block_call(VALUE obj, ID mid, int argc, VALUE *argv, VALUE
(*bl_proc)(ANYARGS), VALUE data2)
{
struct iter_method_arg arg;
@@ -5776,7 +5805,7 @@ rb_call0(VALUE klass, VALUE recv, ID id,
Data_Get_Struct(body->nd_cval, struct BLOCK, data);
EXEC_EVENT_HOOK(RUBY_EVENT_CALL, data->body, recv, id, klass);
}
int flags = YIELD_PUBLIC_DEF;
if (args[0] != Qundef) flags |= YIELD_ARY_ARGS;
return rb_yield_0(args[0], args[1], ruby_cbase, flags);
/* block eval under the class/module context */
@@ -6507,7 +6534,7 @@ specific_eval(int argc, VALUE *argv, VAL
if (argc > 0) {
rb_raise(rb_eArgError, “wrong number of arguments (%d for 0)”,
argc);
}
@@ -8426,7 +8453,7 @@ block_orphan(struct BLOCK *data)
}
static VALUE
-proc_invoke(VALUE proc, VALUE args /* OK /, VALUE self, VALUE klass,
int call)
+proc_invoke(VALUE proc, VALUE args / OK */, VALUE self, VALUE klass)
{
struct BLOCK _block;
struct BLOCK data;
@@ -8434,12 +8461,10 @@ proc_invoke(VALUE proc, VALUE args / OK
int state;
volatile int safe = ruby_safe_level;
volatile VALUE old_wrapper = ruby_wrapper;
volatile int lambda;
VALUE bvar = 0;
Data_Get_Struct(proc, struct BLOCK, data);
if (pcall) break;
return_jump(result);
break;
/*
prc.call(params,...) => obj
prc.yield(params,...) => obj
prc[params,...] => obj
Kernel.proc, generates anProc.new, extra parameters are silently discarded.Kernel.lambda, generates anProc.new orKernel.proc, extra parameters are silently discarded.Proc#yield.a_proc = Proc.new {|a, *b| b.collect {|i| i*a }}
a_proc.call(9, 1, 2, 3) #=> [9, 18, 27]
a_proc.yield(9, 1, 2, 3) #=> [9, 18, 27]
a_proc[9, 1, 2, 3] #=> [9, 18, 27]
a_proc = Proc.new {|a,b| a}
a_proc.call(1,2,3)
prog.rb:5: wrong number of arguments (3 for 2) (ArgumentError)
from prog.rb:4:in `call'
from prog.rb:5
a_proc.call(1,2,3) #=> 1
a_lambda = lambda {|a| p a }
a_lambda.call(1,2) #=> wrong number of arguments (2 for
VALUE
rb_proc_call(VALUE proc, VALUE args /* OK */)
{
-/*
prc.yield(params,...) => obj
a_proc = Proc.new {|a, *b| b.collect {|i| i*a }}
a_proc.yield(9, 1, 2, 3) #=> [9, 18, 27]
a_proc.yield([9, 1, 2, 3]) #=> [9, 18, 27]
a_proc = Proc.new {|a,b| a}
a_proc.yield(1,2,3) # => [1]
-VALUE
-rb_proc_yield(int argc, VALUE *argv, VALUE proc)
-{
case 1:
return proc_invoke(proc, argv[0], Qundef, 0, 0);
case 0:
default:
/* :nodoc: */
@@ -8591,7 +8578,7 @@ rb_proc_arity(VALUE proc)
var = data->var;
if (var == 0) {
if (!data->body) return 0;
VALUE proc = rb_iterate_splat((VALUE(*)(VALUE))mproc, 0, func,
val);
Data_Get_Struct(proc, struct BLOCK, data);
data->body->nd_state = YIELD_FUNC_AVALUE;
@@ -9424,7 +9411,7 @@ method_proc(VALUE method)
if (nd_type(mdata->body) == NODE_BMETHOD) {
return mdata->body->nd_cval;
}
th->result = rb_proc_yield(RARRAY_LEN(arg), RARRAY_PTR(arg),
proc);
th->result = rb_proc_call(proc, arg);
@@ -1027,7 +1027,7 @@ static int
each_i(VALUE key, VALUE value)
{
if (key == Qundef) return ST_CONTINUE;
RCS file: /src/ruby/node.h,v
retrieving revision 1.78
diff -u -p -r1.78 node.h
— node.h 23 Sep 2006 21:29:47 -0000 1.78
+++ node.h 26 Sep 2006 16:52:04 -0000
@@ -120,6 +120,7 @@ enum node_type {
NODE_BMETHOD,
NODE_MEMO,
NODE_IFUNC,
$$ = $2;
$$ = NEW_MASGN(NEW_LIST($2), 0);
/*%
$$ = dispatch1(mlhs_paren, $2);
%*/
@@ -2888,13 +2888,7 @@ block_param0 : mlhs_item
block_param : block_param0
{
/%%%/
if ($1->nd_alen == 1) {
$$ = $1->nd_head;
rb_gc_force_recycle((VALUE)$1);
}
else {
$$ = NEW_MASGN($1, 0);
}
$$ = NEW_MASGN($1, 0);
/*%
$$ = blockvar_new($1);
%*/
@@ -2902,7 +2896,7 @@ block_param : block_param0
| block_param0 ‘,’
{
/%%%/
$$ = NEW_MASGN($1, 0);
$$ = NEW_MASGN($1, -2);
/*%
$$ = blockvar_new($1);
%*/
@@ -7837,11 +7831,7 @@ new_yield(NODE *node)
if (node) {
no_blockarg(node);
node = node->nd_head;
state = Qfalse;
if (TYPE(result) == T_STRING)
rb_yield(result);
else
rb_yield_splat(result);
RCS file: /src/ruby/lib/mkmf.rb,v
retrieving revision 1.263
diff -u -p -r1.263 mkmf.rb
— lib/mkmf.rb 26 Sep 2006 16:05:21 -0000 1.263
+++ lib/mkmf.rb 26 Sep 2006 16:52:04 -0000
@@ -1230,7 +1230,7 @@ EXTSTATIC = #{$static || “”}
STATIC_LIB = #{staticlib unless $static.nil?}
#{!$extout && defined?($installed_list) ? “INSTALLED_LIST =
#{$installed_list}\n” : “”}
"
return block_given ? yield(k) : k
return block_given ? yield(*k) : k
list.__send__(iter_method) {|v|
list.__send__(iter_method) {|*v|
if first
first = false
else
sep.call
end
yield(v)
yield(*v)
}
RCS file: /src/ruby/sample/test.rb,v
retrieving revision 1.102
diff -u -p -r1.102 test.rb
— sample/test.rb 25 Sep 2006 06:07:35 -0000 1.102
+++ sample/test.rb 26 Sep 2006 16:52:04 -0000
@@ -134,13 +134,13 @@ def f; yield [[]]; end; f {|a| test_ok(a
def f; yield [[]]; end; f {|a| test_ok(a == [])}
def f; yield [[1]]; end; f {|a| test_ok(a == [1])}
def f; yield [*[1,2]]; end; f {|a| test_ok(a == [1,2])}
-def f; yield *[]; end; f {|a| test_ok(a == [])}
-def f; yield *[1]; end; f {|a| test_ok(a == [1])}
-def f; yield *[nil]; end; f {|a| test_ok(a == [nil])}
-def f; yield *[[]]; end; f {|a| test_ok(a == [[]])}
-def f; yield [[]]; end; f {|a| test_ok(a == [])}
-def f; yield [[1]]; end; f {|a| test_ok(a == [1])}
-def f; yield [[1,2]]; end; f {|a| test_ok(a == [1,2])}
+def f; yield *[]; end; f {|a| test_ok(a == nil)}
+def f; yield *[1]; end; f {|a| test_ok(a == 1)}
+def f; yield *[nil]; end; f {|a| test_ok(a == nil)}
+def f; yield *[[]]; end; f {|a| test_ok(a == [])}
+def f; yield [[]]; end; f {|a| test_ok(a == nil)}
+def f; yield [[1]]; end; f {|a| test_ok(a == 1)}
+def f; yield [[1,2]]; end; f {|a| test_ok(a == 1)}
def f; yield; end; f {|a,| test_ok(a == nil)}
def f; yield nil; end; f {|a,| test_ok(a == nil)}
@@ -156,7 +156,7 @@ def f; yield [*[1,2]]; end; f {|a,| test
def f; yield *[]; end; f {|a,| test_ok(a == nil)}
def f; yield *[1]; end; f {|a,| test_ok(a == 1)}
def f; yield *[nil]; end; f {|a,| test_ok(a == nil)}
-def f; yield *[[]]; end; f {|a,| test_ok(a == [])}
+def f; yield *[[]]; end; f {|a,| test_ok(a == nil)}
def f; yield [[]]; end; f {|a,| test_ok(a == nil)}
def f; yield [[1]]; end; f {|a,| test_ok(a == 1)}
def f; yield [[1,2]]; end; f {|a,| test_ok(a == 1)}
@@ -164,14 +164,14 @@ def f; yield [[1,2]]; end; f {|a,| tes
def f; yield; end; f {|*a| test_ok(a == [])}
def f; yield nil; end; f {|*a| test_ok(a == [nil])}
def f; yield 1; end; f {|*a| test_ok(a == [1])}
-def f; yield []; end; f {|*a| test_ok(a == [])}
-def f; yield [1]; end; f {|*a| test_ok(a == [1])}
-def f; yield [nil]; end; f {|*a| test_ok(a == [nil])}
-def f; yield [[]]; end; f {|*a| test_ok(a == [[]])}
-def f; yield [1,2]; end; f {|a| test_ok(a == [1,2])}
-def f; yield [[]]; end; f {|a| test_ok(a == [])}
-def f; yield [[1]]; end; f {|a| test_ok(a == [1])}
-def f; yield [[1,2]]; end; f {|*a| test_ok(a == [1,2])}
+def f; yield []; end; f {|*a| test_ok(a == [[]])}
+def f; yield [1]; end; f {|*a| test_ok(a == [[1]])}
+def f; yield [nil]; end; f {|*a| test_ok(a == [[nil]])}
+def f; yield [[]]; end; f {|*a| test_ok(a == [[[]]])}
+def f; yield [1,2]; end; f {|a| test_ok(a == [[1,2]])}
+def f; yield [[]]; end; f {|a| test_ok(a == [[]])}
+def f; yield [[1]]; end; f {|a| test_ok(a == [[1]])}
+def f; yield [[1,2]]; end; f {|*a| test_ok(a == [[1,2]])}
def f; yield *[]; end; f {|*a| test_ok(a == [])}
def f; yield *[1]; end; f {|a| test_ok(a == [1])}
@@ -195,7 +195,7 @@ def f; yield [[1,2]]; end; f {|a,b,*c|
def f; yield *[]; end; f {|a,b,*c| test_ok([a,b,c] == [nil,nil,[]])}
def f; yield *[1]; end; f {|a,b,*c| test_ok([a,b,c] == [1,nil,[]])}
def f; yield *[nil]; end; f {|a,b,*c| test_ok([a,b,c] == [nil,nil,[]])}
-def f; yield *[[]]; end; f {|a,b,*c| test_ok([a,b,c] == [[],nil,[]])}
+def f; yield *[[]]; end; f {|a,b,*c| test_ok([a,b,c] == [nil,nil,[]])}
def f; yield [[]]; end; f {|a,b,*c| test_ok([a,b,c] == [nil,nil,[]])}
def f; yield [[1]]; end; f {|a,b,*c| test_ok([a,b,c] == [1,nil,[]])}
def f; yield [[1,2]]; end; f {|a,b,*c| test_ok([a,b,c] == [1,2,[]])}
@@ -964,23 +964,23 @@ IterTest.new([1]).each1 {|x| test_ok(x =
IterTest.new([2]).each2 {|x| test_ok(x == [2])}
#IterTest.new([3]).each3 {|x| test_ok(x == 3)}
IterTest.new([4]).each4 {|x| test_ok(x == 4)}
-IterTest.new([5]).each5 {|x| test_ok(x == [5])}
+IterTest.new([5]).each5 {|x| test_ok(x == 5)}
IterTest.new([6]).each6 {|x| test_ok(x == [6])}
#IterTest.new([7]).each7 {|x| test_ok(x == 7)}
IterTest.new([8]).each8 {|x| test_ok(x == 8)}
IterTest.new([[0]]).each0 {|x| test_ok(x == [0])}
-IterTest.new([[1]]).each1 {|x| test_ok(x == 1)}
-IterTest.new([[2]]).each2 {|x| test_ok(x == [2])}
+IterTest.new([[1]]).each1 {|x| test_ok(x == [1])}
+IterTest.new([[2]]).each2 {|x| test_ok(x == [[2]])}
IterTest.new([[3]]).each3 {|x| test_ok(x == 3)}
IterTest.new([[4]]).each4 {|x| test_ok(x == [4])}
IterTest.new([[5]]).each5 {|x| test_ok(x == [5])}
-IterTest.new([[6]]).each6 {|x| test_ok(x == [6])}
-IterTest.new([[7]]).each7 {|x| test_ok(x == [7])}
+IterTest.new([[6]]).each6 {|x| test_ok(x == [[6]])}
+IterTest.new([[7]]).each7 {|x| test_ok(x == 7)}
IterTest.new([[8]]).each8 {|x| test_ok(x == [8])}
-IterTest.new([[0,0]]).each0 {|*x| test_ok(x == [0,0])}
-IterTest.new([[8,8]]).each8 {|*x| test_ok(x == [8,8])}
+IterTest.new([[0,0]]).each0 {|*x| test_ok(x == [[0,0]])}
+IterTest.new([[8,8]]).each8 {|*x| test_ok(x == [[8,8]])}
RCS file: /src/ruby/test/ruby/test_assignment.rb,v
retrieving revision 1.10
diff -u -p -r1.10 test_assignment.rb
— test/ruby/test_assignment.rb 10 Jul 2006 08:36:34 -0000 1.10
+++ test/ruby/test_assignment.rb 26 Sep 2006 16:52:04 -0000
@@ -90,22 +90,22 @@ class TestAssignment < Test::Unit::TestC
def f; yield([[1]]); end; f {|a| assert_equal([1], a)}; undef f
def f; yield([[1,2]]); end; f {|a| assert_equal([1,2], a)}; undef
f
def f; yield(*[1]); end; f {|a| assert_equal(1, a)}; undef f
def f; yield(*[nil]); end; f {|a| assert_equal(nil, a)}; undef f
def f; yield(*[[]]); end; f {|a| assert_equal([], a)}; undef f
def f; yield([[1]]); end; f {|a| assert_equal(1, a)}; undef f
def f; yield; end; f {|*a| assert_equal([], a)}; undef f
def f; yield(nil); end; f {|*a| assert_equal([nil], a)}; undef f
def f; yield(1); end; f {|*a| assert_equal([1], a)}; undef f
def f; yield([]); end; f {|*a| assert_equal([[]], a)}; undef f
def f; yield([1]); end; f {|*a| assert_equal([[1]], a)}; undef f
def f; yield([nil]); end; f {|*a| assert_equal([[nil]], a)}; undef
f
def f; yield([[]]); end; f {|*a| assert_equal([[[]]], a)}; undef f
def f; yield([1,2]); end; f {|*a| assert_equal([[1,2]], a)}; undef
f
def f; yield([*[]]); end; f {|*a| assert_equal([[]], a)}; undef f
def f; yield([*[1]]); end; f {|*a| assert_equal([[1]], a)}; undef f
def f; yield([*[1,2]]); end; f {|*a| assert_equal([[1,2]], a)};
undef f
def f; yield(*[]); end; f {|a| assert_equal([], a)}; undef f
def f; yield([1]); end; f {|a| assert_equal([1], a)}; undef f
@@ -129,7 +129,7 @@ class TestAssignment < Test::Unit::TestC
def f; yield([]); end; f {|a,b,c| assert_equal([nil,nil,[]],
[a,b,c])}; undef f
def f; yield([1]); end; f {|a,b,c| assert_equal([1,nil,[]],
[a,b,c])}; undef f
def f; yield([nil]); end; f {|a,b,*c| assert_equal([nil,nil,[]],
[a,b,c])}; undef f
IterTest.new([5]).each5 {|x| assert_equal(5, x)}
IterTest.new([6]).each6 {|x| assert_equal([6], x)}
IterTest.new([8]).each8 {|x| assert_equal(8, x)}
IterTest.new([[0]]).each0 {|x| assert_equal([0], x)}
def m(var)
@@ -359,6 +359,9 @@ class TestIterator < Test::Unit::TestCas
class H
def each
yield [:key, :value]
h.each{|*a| assert_equal([:key, :value], a)}
h.each{|a,| assert_equal(:key, a)}
h.each{|*a| assert_equal([[:key, :value]], a)}
h.each{|k,v| assert_equal([:key, :value], [k,v])}
h.each_pair{|a| assert_equal(:key, a)}
h.each_pair{|a,| assert_equal(:key, a)}
h.each_pair{|*a| assert_equal([:key, :value], a)}
h.each_pair{|k,v| assert_equal([:key, :value], [k,v])}
This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.
Sponsor our Newsletter | Privacy Policy | Terms of Service | Remote Ruby Jobs