Forum: Ruby-core [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics

E8a419959139f3f505b49bb95f7e7afe?d=identicon&s=25 Joshua Ballanco (jballanc)
on 2013-01-28 00:11
(Received via mailing list)
Issue #7747 has been reported by jballanc (Joshua Ballanco).

----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747

Author: jballanc (Joshua Ballanco)
Status: Open
Priority: Normal
Assignee:
Category:
Target version:


=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
E8a419959139f3f505b49bb95f7e7afe?d=identicon&s=25 Joshua Ballanco (jballanc)
on 2013-01-28 00:20
(Received via mailing list)
Issue #7747 has been updated by jballanc (Joshua Ballanco).


=begin
It should also be possible to implement feature request #6710 with this
API. The "isolated" binding mentioned in that request could be
implemented as:

    def isolated_eval(src)
      isolated = Binding.new #=> No source binding creates an empty
environment
      isolated.eval(src)
      TOPLEVEL_BINDING.merge(isolated)
    end

=end

----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-35679

Author: jballanc (Joshua Ballanco)
Status: Open
Priority: Normal
Assignee:
Category:
Target version:


=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
F7a3bd35a314fc6260792d189fb9527c?d=identicon&s=25 pasvan (paster okan) (Guest)
on 2013-03-07 23:48
(Received via mailing list)
Issue #7747 has been updated by pasvan (paster okan).


Penis büyütücü ilaç, draje yada yap olarak bilinen v-pills isimli ilaç
v-pills yorumları yada siparişi hakkındaki haberi okumak için tıkla. Her
erkek partnerinin düzenli cinsel hayatının olmasını, orgazmı tatmasını,
mutlu bir kadın cinselliği yaşamasını ister. Cinselilişkinin kaliteli
olması bir kadının isteksizliğini olumlu yönde etkileyebilir.
Kalitesizlik sadece erkeklik organı büyüklüğü veya geciktirme spreyleri
kullanılmadığı için erken boşalmanın yaşanması ile ilgili değildir.
Kadın cinsel ilişkide orgazm olmalı, erkek ise ereksiyon yaşamalıdır.
Kadına istek arttırıcı bayan damla yani afrodizyak parfüm almak yerine
<a href="http://www.vpillssatis.gen.tr/kullanimi.html" title="v-pills
kullanmanız">v-pills kullanmanız</a> daha iyi olucaktır. İnsan için
beyin ve zeka konusunda yararlı vitamin olan <a
href="http://www.nzt48turkiye.gen.tr/index.html" title="nzt 48">nzt
48</a> panik atak konusundada etkilidir. Nzt
  48 vitamini içerisinde en çok bulunan vitamin ise B vitaminidir.
Kibarlı panax'ın sahibi mustafa eraslanın üretmiş olduğu ve içinde
ginseng maddeside bulunan <a href="http://www.panaxtr.com/"
title="panax">panax</a> %100 doğal ve % 100 bitkisel bir üründür. Panax
siparişi vermek isterseniz sitemize tıklamanız yeterlidir.

----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-37369

Author: jballanc (Joshua Ballanco)
Status: Open
Priority: Normal
Assignee:
Category:
Target version:


=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
F7a3bd35a314fc6260792d189fb9527c?d=identicon&s=25 pasvan (paster okan) (Guest)
on 2013-09-23 07:06
(Received via mailing list)
Issue #7747 has been updated by pasvan (paster okan).


2 ayrı tavsiye sitemiz:

http://www.v-pillsgold.web.tr
http://www.v-pillsgold.web.tr

bilgi almak için tıklayın.
----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-41924

Author: jballanc (Joshua Ballanco)
Status: Open
Priority: Normal
Assignee:
Category:
Target version:


=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
F7a3bd35a314fc6260792d189fb9527c?d=identicon&s=25 unknown (Guest)
on 2014-03-12 14:52
(Received via mailing list)
Issue #7747 has been updated by paster okan.


Fat block zayıflama ürünü kilo verdirici bir üründür. Yorumları
sitesinde mvcuttur. doktorlar tarafından onaylı ve sağlık bakanlığı
izinlidir. <a href="http://www.fatblockshop.com">Fat block</a> yağ
tutucu özelliği sayesinde her derde devadır. Diyet listeleri hakkında
ender saraç ve karatay bi diyet hazırlamıştır ve <a
href="http://www.zayiflax.com">zayıflama</a> konusunda birebir
ürünlerdir.. Cinsel ürünler kalitelidir. Aynı zamanda <a
href="http://www.sexdukkan.com">erotik shop</a> olarakta hizmet
vermektedir.

----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-45739

* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
* Category:
* Target version:
----------------------------------------
=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
Ad1b6d75c7dccb2ca5d1fd21a703468b?d=identicon&s=25 unknown (Guest)
on 2014-05-12 20:42
(Received via mailing list)
Issue #7747 has been updated by tülay dogan.


http://www.orjinalkirmizibal.gen.tr/
http://www.yesilkahveler.com/
http://www.saunaesofman.web.tr/
http://alkadays.gen.tr/
http://www.lipo-shot.gen.tr/
http://www.orjinalkornismatik.com/
http://www.dogalgeciktiriciler.com/
http://www.dexesampuan.gen.tr/
http://www.sarimsakcayishop.com/


----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-46702

* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
* Category:
* Target version:
----------------------------------------
=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
F1d6cc2b735bfd82c8773172da2aeab9?d=identicon&s=25 Nobuyoshi Nakada (nobu)
on 2014-05-13 01:36
(Received via mailing list)
Issue #7747 has been updated by Nobuyoshi Nakada.


spam




----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-46703

* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
* Category:
* Target version:
----------------------------------------
=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
F1d6cc2b735bfd82c8773172da2aeab9?d=identicon&s=25 Nobuyoshi Nakada (nobu)
on 2014-05-13 02:16
(Received via mailing list)
Issue #7747 has been updated by Nobuyoshi Nakada.


Joshua Ballanco wrote:
> It should also be possible to implement feature request #6710 with this API. The
"isolated" binding mentioned in that request could be implemented as:
>
> ~~~ruby
> def isolated_eval(src)
>   isolated = Binding.new #=> No source binding creates an empty environment
>   isolated.eval(src)
>   TOPLEVEL_BINDING.merge(isolated)
> end
> ~~~


----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-46704

* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
* Category:
* Target version:
----------------------------------------
=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
2e2d726cb5fe9447ed20cbc146c50be4?d=identicon&s=25 unknown (Guest)
on 2014-11-10 12:16
(Received via mailing list)
Issue #7747 has been updated by sertac kaya.


Nice.
http://www.v-pillsbuyut.com
http://www.orjinalkirmizibal.gen.tr

----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-49869

* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
* Category:
* Target version:
----------------------------------------
=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
2e2d726cb5fe9447ed20cbc146c50be4?d=identicon&s=25 unknown (Guest)
on 2014-11-22 18:14
(Received via mailing list)
Issue #7747 has been updated by sertac kaya.


cool
http://www.orjinalepila.com
http://www.rep-hair.net/
http://www.orjinalroyalhoney.net/
http://www.padisah-macunu.net

----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-50052

* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
* Category:
* Target version:
----------------------------------------
=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
2e2d726cb5fe9447ed20cbc146c50be4?d=identicon&s=25 unknown (Guest)
on 2014-11-22 21:46
(Received via mailing list)
Issue #7747 has been updated by sertac kaya.


forgot this one http://www.youtube.com/watch?v=Rj1rOhGYHi4

----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-50053

* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
* Category:
* Target version:
----------------------------------------
=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
2e2d726cb5fe9447ed20cbc146c50be4?d=identicon&s=25 unknown (Guest)
on 2014-11-23 12:21
(Received via mailing list)
Issue #7747 has been updated by sertac kaya.


nice job before:

http://www.vpillssatis.gen.tr
http://www.orjinalv-pills.com
http://www.v-pillsturk.com



----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-50059

* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
* Category:
* Target version:
----------------------------------------
=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
2e2d726cb5fe9447ed20cbc146c50be4?d=identicon&s=25 unknown (Guest)
on 2014-11-23 12:22
(Received via mailing list)
Issue #7747 has been updated by sertac kaya.


her i am and,

http://www.v-pills.bbs.tr
http://www.v-pillsbuyut.com/pdf

----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-50060

* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
* Category:
* Target version:
----------------------------------------
=begin
Currently, the only way to create a new instance of Binding is to get a
copy of the current scope's binding, or ask some other object for its
binding. In either case, the binding object returned always has
semantics identical to the original binding. In other words, a binding
object used with eval is capable of (not necessarily an exhaustive
list):

* redefining methods on the binding target
* defining new methods on the binding target
* getting/setting instance variables
* getting/creating new constants

This feature proposal would introduce a new mechanism for creating a
binding and adjusting its relationship with the source binding. For
example, if you have a class (({Foo})) defined like so:

    class Foo
      def say
        puts "hello!"
      end
    end

Then you would be able to create a new binding that ((*won't*))
propagate new definitions to the parent binding like so:

    new_binding = Binding.new(Foo)
    new_binding.propagate = false
    new_binding.eval("def shout; puts 'HI!'; end")

    Foo.new.say #=> "hello!"
    Foo.new.shout #=> No Method Error
    new_binding.eval("Foo.new.say") #=> "hello"
    new_binding.eval("Foo.new.shout") #=> "HI!"

If, additionally, we introduce a way to merge or combine bindings, then
this API could actually be used to implement refinements in pure Ruby
like so (note I am also assuming that (({Binding#eval})) gains the
ability to take a block):

    class Module
      def refine(klass, &block)
        @refined_bindings ||= {}
        refinement_binding = Binding.new(klass)
        refinement_binding.propagate = false
        refinement_binding.shadow = true
        refinement_binding.eval &block
        (@refined_bindings[self.name] ||= []) << refinement_binding
      end

      def using(mod)
        @refined_bindings[mod].each { |refinement|
self.binding.merge(refinement) }
      end
    end

Following is the preliminary list of additional APIs I am tentatively
proposing (though I expect this to change with additional discussion):

* (({Binding.new(an_object)})) - creates a new Binding object that
"inherits" the binding of the argument; essentially equivalent to
(({an_object.send(:binding).dup}))
* (({Binding#propagate}))/(({Binding#propagate=})) - boolean; determines
whether new method, class, or Constant defs are propagated into the
"parent" binding's scope
* (({Binding#shadow}))/(({Binding#shadow=})) - boolean; sets whether or
not new values for existing methods/constants/variables can be set
* (({Binding#freeze})) - causes the Binding to capture all existing
methods/constants/variables in scope at call time, and "disconnect" from
the parent binding, so that any updates to definitions or values are no
longer reflected into the "child" binding
* (({Binding#merge(other_binding)})) - combines the
method/constant/variable bindings in (({other_binding})) with the
receiver; effectively shadows the "parent" of (({other_binding})) within
the receiver binding
=end
This topic is locked and can not be replied to.