* [ruby-core:51716] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
@ 2013-01-27 23:18 ` jballanc (Joshua Ballanco)
2013-03-07 22:48 ` [ruby-core:53201] " pasvan (paster okan)
` (15 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: jballanc (Joshua Ballanco) @ 2013-01-27 23:18 UTC (permalink / raw)
To: ruby-core
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
--
http://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:53201] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
2013-01-27 23:18 ` [ruby-core:51716] [CommonRuby - Feature #7747] " jballanc (Joshua Ballanco)
@ 2013-03-07 22:48 ` pasvan (paster okan)
2013-09-23 5:05 ` [ruby-core:57312] " pasvan (paster okan)
` (14 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: pasvan (paster okan) @ 2013-03-07 22:48 UTC (permalink / raw)
To: ruby-core
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
--
http://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:57312] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
2013-01-27 23:18 ` [ruby-core:51716] [CommonRuby - Feature #7747] " jballanc (Joshua Ballanco)
2013-03-07 22:48 ` [ruby-core:53201] " pasvan (paster okan)
@ 2013-09-23 5:05 ` pasvan (paster okan)
2014-03-12 13:52 ` [ruby-core:61436] " bookingfirm
` (13 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: pasvan (paster okan) @ 2013-09-23 5:05 UTC (permalink / raw)
To: ruby-core
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
--
http://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:61436] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (2 preceding siblings ...)
2013-09-23 5:05 ` [ruby-core:57312] " pasvan (paster okan)
@ 2014-03-12 13:52 ` bookingfirm
2014-05-12 18:41 ` [ruby-core:62549] " yesilkahvezayiflama
` (12 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: bookingfirm @ 2014-03-12 13:52 UTC (permalink / raw)
To: ruby-core
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
--
http://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:62549] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (3 preceding siblings ...)
2014-03-12 13:52 ` [ruby-core:61436] " bookingfirm
@ 2014-05-12 18:41 ` yesilkahvezayiflama
2014-05-12 23:35 ` [ruby-core:62550] " nobu
` (11 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: yesilkahvezayiflama @ 2014-05-12 18:41 UTC (permalink / raw)
To: ruby-core
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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:62550] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (4 preceding siblings ...)
2014-05-12 18:41 ` [ruby-core:62549] " yesilkahvezayiflama
@ 2014-05-12 23:35 ` nobu
2014-05-13 0:15 ` [ruby-core:62551] " nobu
` (10 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: nobu @ 2014-05-12 23:35 UTC (permalink / raw)
To: ruby-core
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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:62551] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (5 preceding siblings ...)
2014-05-12 23:35 ` [ruby-core:62550] " nobu
@ 2014-05-13 0:15 ` nobu
2014-11-10 11:15 ` [ruby-core:66170] " sertackaya
` (9 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: nobu @ 2014-05-13 0:15 UTC (permalink / raw)
To: ruby-core
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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:66170] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (6 preceding siblings ...)
2014-05-13 0:15 ` [ruby-core:62551] " nobu
@ 2014-11-10 11:15 ` sertackaya
2014-11-22 17:13 ` [ruby-core:66417] " sertackaya
` (8 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: sertackaya @ 2014-11-10 11:15 UTC (permalink / raw)
To: ruby-core
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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:66417] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (7 preceding siblings ...)
2014-11-10 11:15 ` [ruby-core:66170] " sertackaya
@ 2014-11-22 17:13 ` sertackaya
2014-11-22 20:45 ` [ruby-core:66418] " sertackaya
` (7 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: sertackaya @ 2014-11-22 17:13 UTC (permalink / raw)
To: ruby-core
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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:66418] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (8 preceding siblings ...)
2014-11-22 17:13 ` [ruby-core:66417] " sertackaya
@ 2014-11-22 20:45 ` sertackaya
2014-11-23 11:21 ` [ruby-core:66426] " sertackaya
` (6 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: sertackaya @ 2014-11-22 20:45 UTC (permalink / raw)
To: ruby-core
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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:66426] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (9 preceding siblings ...)
2014-11-22 20:45 ` [ruby-core:66418] " sertackaya
@ 2014-11-23 11:21 ` sertackaya
2014-11-23 11:21 ` [ruby-core:66427] " sertackaya
` (5 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: sertackaya @ 2014-11-23 11:21 UTC (permalink / raw)
To: ruby-core
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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:66427] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (10 preceding siblings ...)
2014-11-23 11:21 ` [ruby-core:66426] " sertackaya
@ 2014-11-23 11:21 ` sertackaya
2015-01-18 8:09 ` [ruby-core:67674] " sertackaya
` (4 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: sertackaya @ 2014-11-23 11:21 UTC (permalink / raw)
To: ruby-core
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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:67674] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (11 preceding siblings ...)
2014-11-23 11:21 ` [ruby-core:66427] " sertackaya
@ 2015-01-18 8:09 ` sertackaya
2015-01-18 19:48 ` [ruby-core:67677] " fatblockshop
` (3 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: sertackaya @ 2015-01-18 8:09 UTC (permalink / raw)
To: ruby-core
Issue #7747 has been updated by sertac kaya.
Ürünümüzün yan etkisi yoktur.
http://v-pillsbuyut.com/v-pills-yan-etkileri.html
----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-51090
* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
----------------------------------------
=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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:67677] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (12 preceding siblings ...)
2015-01-18 8:09 ` [ruby-core:67674] " sertackaya
@ 2015-01-18 19:48 ` fatblockshop
2015-02-25 9:15 ` [ruby-core:68305] " sertackaya
` (2 subsequent siblings)
16 siblings, 0 replies; 18+ messages in thread
From: fatblockshop @ 2015-01-18 19:48 UTC (permalink / raw)
To: ruby-core
Issue #7747 has been updated by ceren deren.
nice one http://evenakliyatevden.net/
----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-51094
* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
----------------------------------------
=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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:68305] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (13 preceding siblings ...)
2015-01-18 19:48 ` [ruby-core:67677] " fatblockshop
@ 2015-02-25 9:15 ` sertackaya
2015-07-09 5:09 ` [ruby-core:69904] " 2851820660
2015-07-09 5:10 ` [ruby-core:69905] " 2851820660
16 siblings, 0 replies; 18+ messages in thread
From: sertackaya @ 2015-02-25 9:15 UTC (permalink / raw)
To: ruby-core
Issue #7747 has been updated by sertac kaya.
nice one
https://www.youtube.com/watch?v=ckB1yx4QalM
http://v-pillsbuyut.com
----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-51659
* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
----------------------------------------
=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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:69904] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (14 preceding siblings ...)
2015-02-25 9:15 ` [ruby-core:68305] " sertackaya
@ 2015-07-09 5:09 ` 2851820660
2015-07-09 5:10 ` [ruby-core:69905] " 2851820660
16 siblings, 0 replies; 18+ messages in thread
From: 2851820660 @ 2015-07-09 5:09 UTC (permalink / raw)
To: ruby-core
Issue #7747 has been updated by 11 22.
http://www.inspiredhypnosis.co.uk/daocplat.html
----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-53323
* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
----------------------------------------
=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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread
* [ruby-core:69905] [CommonRuby - Feature #7747] Expanded API for Binding semantics
2013-01-27 23:09 [ruby-core:51714] [CommonRuby - Feature #7747][Open] Expanded API for Binding semantics jballanc (Joshua Ballanco)
` (15 preceding siblings ...)
2015-07-09 5:09 ` [ruby-core:69904] " 2851820660
@ 2015-07-09 5:10 ` 2851820660
16 siblings, 0 replies; 18+ messages in thread
From: 2851820660 @ 2015-07-09 5:10 UTC (permalink / raw)
To: ruby-core
Issue #7747 has been updated by 11 22.
http://www.software-rating.com/
http://www.smartlogi.com/
http://www.shareorder.com/
http://www.gzs168.com/
http://www.aimooimage.com/
http://www.chinatowngate.net/
----------------------------------------
Feature #7747: Expanded API for Binding semantics
https://bugs.ruby-lang.org/issues/7747#change-53324
* Author: Joshua Ballanco
* Status: Open
* Priority: Normal
* Assignee:
----------------------------------------
=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
--
https://bugs.ruby-lang.org/
^ permalink raw reply [flat|nested] 18+ messages in thread