Great!  I tried something similar but I must have botched it somehow.

Oh.... I bet I tried e(&p1)

On Dec 23, 2012, at 1:15 PM, trans (Thomas Sawyer) wrote:

>=20
> Issue #7612 has been updated by trans (Thomas Sawyer).
>=20
>=20
> =3Dbegin
> Use `&`:
>=20
>  e.each(&p1)
>  e.each(&m2)
>  e.each(&p2)
> =3Dend
>=20
> ----------------------------------------
> Feature #7612: Enumerators take a proc
> https://bugs.ruby-lang.org/issues/7612#change-35034
>=20
> Author: pedz (Perry Smith)
> Status: Open
> Priority: Normal
> Assignee:=20
> Category:=20
> Target version:=20
>=20
>=20
> If there is already a clean syntax for this, I apologize.  I sure =
could not find it.
>=20
> class Foo
>  def initialize
>    @inst =3D 18
>  end
>=20
>  def meth(a, b)
>    puts "method #{@inst} #{a} #{b}"
>  end
> end
>=20
> foo =3D Foo.new
>=20
> e =3D %w{a b c}.each_with_index
> p1 =3D Proc.new { |a, b| puts "proc #{a} #{b}" }
> m2 =3D foo.method(:meth)
> p2 =3D m2.to_proc
>=20
> # Current Syntax possibilities
> e.each { |a, b| puts "direct #{a} #{b}" }
> e.each { |a, b| foo.meth(a, b) }
> e.each { |a, b| p1.call(a,b) }
> e.each { |a, b| m2.call(a,b) }
> e.each { |a, b| p2.call(a,b) }
>=20
> # Proposed Addition
>=20
> e.each(p1) # same as e.each { |a, b| p1.call(a,b) }
> e.each(m2) # same as e.each { |a, b| m2.call(a,b) }
> e.each(p2) # same as e.each { |a, b| p2.call(a,b) }
>=20
> # In the case of a method or lambda, the arguments are checked and =
possible errors thrown.
> # In the case of a proc, the proc "tricks" apply
>=20
> To add readability, an "apply_to" method could be added:
>=20
> e.apply_to(p1)
>=20
> The extra "each" bothers me since the enumerator already has an "each" =
associated with it.
>=20
>=20
>=20
> --=20
> http://bugs.ruby-lang.org/
>=20