New, but this seems odd...

[Andrew Wagner]

[Note: parts of this message were removed to make it a legal post.]

Ok, granted that I'm pretty new to ruby, but this seems odd to me:

irb(main):001:0> x = [1,2,3]
=> [1, 2, 3]
irb(main):002:0> x.delete 2
=> 2
irb(main):003:0> x
=> [1, 3]

With this behavior, wouldn't "delete!" be a more appropriate name?

 

[Rob Biedenharn]

Ok, granted that I'm pretty new to ruby, but this seems odd to me:

irb(main):001:0> x = [1,2,3]
=> [1, 2, 3]
irb(main):002:0> x.delete 2
=> 2
irb(main):003:0> x
=> [1, 3]

With this behavior, wouldn't "delete!" be a more appropriate name?

Read http://dablog.rubypal.com/2007/8/15/bang-methods-or-danger-will-rubyist

Is there some kind of interpretation of "delete" that doesn't imply
the receiving object will be changed?

Compare Hash#update and Hash#merge, for example. Hash#update changes
the receiving hash, which Hash#merge creates a new hash with extra/
overwritten keys from the argument hash. It shouldn't be too
surprising that Hash#merge! is an alias of Hash#update.

-Rob

Rob Biedenharn
(e-mail address removed) http://AgileConsultingLLC.com/
(e-mail address removed) http://GaslightSoftware.com/

 

[Andrew Wagner]

[Note: parts of this message were removed to make it a legal post.]

That article is helpful, thanks. Somehow I had exactly that idea in my mind,
that the ! implies side effects. I was expecting to get back a new array [1,
3], and that there would be a delete! method defined with the below
behavior. That seems more consistent to me than some vague description that
! means "dangerous" for some value of "dangerous". I guess I still have
plenty to learn. Thanks for the link!

irb(main):001:0> x = [1,2,3]
=> [1, 2, 3]
irb(main):002:0> x.delete 2
=> 2
irb(main):003:0> x
=> [1, 3]

With this behavior, wouldn't "delete!" be a more appropriate name?

Read
http://dablog.rubypal.com/2007/8/15/bang-methods-or-danger-will-rubyist

Is there some kind of interpretation of "delete" that doesn't imply the
receiving object will be changed?

Compare Hash#update and Hash#merge, for example. Hash#update changes the
receiving hash, which Hash#merge creates a new hash with extra/overwritten
keys from the argument hash. It shouldn't be too surprising that
Hash#merge! is an alias of Hash#update.

-Rob

Rob Biedenharn
(e-mail address removed) http://AgileConsultingLLC.com/
(e-mail address removed) http://GaslightSoftware.com/

 

[Josh Cheek]

[Note: parts of this message were removed to make it a legal post.]

irb(main):001:0> x = [1,2,3]
=> [1, 2, 3]
irb(main):002:0> x.delete 2
=> 2
irb(main):003:0> x
=> [1, 3]

With this behavior, wouldn't "delete!" be a more appropriate name?

Read
http://dablog.rubypal.com/2007/8/15/bang-methods-or-danger-will-rubyist

Is there some kind of interpretation of "delete" that doesn't imply the
receiving object will be changed?

x = "123"
x.delete '2' # => "13"
x # => "123"

 

[Johnathon Wright]

With this behavior, wouldn't "delete!" be a more appropriate name?

Is there some kind of interpretation of "delete" that doesn't imply  
the receiving object will be changed?

After some reflection, I can certainly see how you would expect a
bang! there... when working with sets, you often want to manipulate a
set to form a different one.

guests = ['(e-mail address removed)', '(e-mail address removed)', '(e-mail address removed)',
'me']
invitations_to_send = guests.delete('me')

and in fact there are enumerable operators that work that way...

guest_emails = ['(e-mail address removed)', '(e-mail address removed)',
'(e-mail address removed)', 'me']
guests = guest_emails.map{|email| Person.find_by_email( email ) }

whereas

guest_emails.map!{|email| Person.find_by_email( email ) }

So, yes, inconsistent. Sorry, not much that can be done now...

The way to do this would be ...

invitations_to_send = guests - ['me']

or just overwrite delete for your app...

jw