Add Array#first= and Array#last= to std lib

[Robert Klemme]

Hi,

just today I came across a situation where I needed Array#last=
because I wanted to do

an_array.last += 1

Does anybody else see this as useful? Any issues with this? If not
I'll open an RCR.

Kind regards

robert

 

[Joe]

Is there a problem with doing something like this:

an_array[-1] += 1

Joe

 

[George]

Hi,

just today I came across a situation where I needed Array#last=
because I wanted to do

an_array.last += 1

Does anybody else see this as useful? Any issues with this? If not
I'll open an RCR.

I'll bite... ;-)

What would you expect this to do?

[].last = 1

Regards,
George.

 

[Sebastian Hungerecker]

What would you expect this to do?

=A0 [].last =3D 1

The same thing as "[][-1] =3D 1", I'd imagine.
The problem I'm seeing would be this: If you allow arr.last =3D x, you'd al=
so=20
have to allow arr.last(n) =3D x if you want to be consistent, but that's no=
t=20
syntactically possible.


=2D-=20
NP: Katatonia - Endtime
Jabber: (e-mail address removed)
ICQ: 205544826

 

[MonkeeSage]

What would you expect this to do?

[].last = 1

The same thing as "[][-1] = 1", I'd imagine.
The problem I'm seeing would be this: If you allow arr.last = x, you'd also
have to allow arr.last(n) = x if you want to be consistent, but that's not
syntactically possible.

Agree. It's tempting to treat #first / #last as 0 / -1, but in
actuality they are method calls and simply return a value; they don't
subscript an array. Setting #last is not semantically different than
[1,2,3].pop = 4, it's just that #last is just a bit more subtle.

Regards,
Jordan

 

[Trans]

What would you expect this to do?
[].last = 1

The same thing as "[][-1] = 1", I'd imagine.
The problem I'm seeing would be this: If you allow arr.last = x, you'd also
have to allow arr.last(n) = x if you want to be consistent, but that's not
syntactically possible.

Agree. It's tempting to treat #first / #last as 0 / -1, but in
actuality they are method calls and simply return a value; they don't
subscript an array. Setting #last is not semantically different than
[1,2,3].pop = 4, it's just that #last is just a bit more subtle.

I don't see what you are getting at here. #pop is destructive, #last
is not. What does #last return when it is called? It returns a
reference to the last element. So why would #last= do anything other
then set the reference of the last element? Seems obvious to me. So we
can't do last(n) = x, due to syntax constraints, oh well. It would
still be convenient to have the obvious n=1, no arg case. I find that
my programs are usually easier to read when I can use words rather non-
alphabetic symbols.

T.

 

[MonkeeSage]

On Dec 27, 9:55 am, Sebastian Hungerecker <[email protected]>
wrote:

George wrote:
What would you expect this to do?
[].last = 1
The same thing as "[][-1] = 1", I'd imagine.
The problem I'm seeing would be this: If you allow arr.last = x, you'd also
have to allow arr.last(n) = x if you want to be consistent, but that's not
syntactically possible.

Agree. It's tempting to treat #first / #last as 0 / -1, but in
actuality they are method calls and simply return a value; they don't
subscript an array. Setting #last is not semantically different than
[1,2,3].pop = 4, it's just that #last is just a bit more subtle.

I don't see what you are getting at here. #pop is destructive, #last
is not. What does #last return when it is called? It returns a
reference to the last element. So why would #last= do anything other
then set the reference of the last element? Seems obvious to me. So we
can't do last(n) = x, due to syntax constraints, oh well. It would
still be convenient to have the obvious n=1, no arg case. I find that
my programs are usually easier to read when I can use words rather non-
alphabetic symbols.

T.

IOW, #pop returns a value, and this is just what #last does. One could
argue that #last and #[-1] *should be* synonymous (which may be the
point of the proposal); but as it currently stands, #last means the
same thing as `def l(a); a[-1]; end` so it makes no sense to have a
setter for it. Unless the semantics change, (to me at least) it is non-
sense to have #last=. It's the same as a.pop = 3.

Regards,
Jordan

 

[Sebastian Hungerecker]

IOW, #pop returns a value, and this is just what #last does.

How is [] different in that regard? That only returns a value, too.

 

[MonkeeSage]

IOW, #pop returns a value, and this is just what #last does.

How is [] different in that regard? That only returns a value, too.

Exactly. It's not... [] = 3 => syntax error...

Regards,
Jordan

 

[Sebastian Hungerecker]

IOW, #pop returns a value, and this is just what #last does.

How is [] different in that regard? That only returns a value, too.

Exactly. It's not... [] = 3 => syntax error...

That [] there is an emtpy array. That's not the [] I was talking about.
I'm sorry if I wasn't clear, let me rephrase:
You seemed to say that while there is a method Array#[]= (which I assume,
you're ok with, since you haven't stated otherwise), there shouldn't be a
method Array#last= since Array#last only returns a value like Array#pop does.
Now my question to you is: How is Array#[] different in that regard than
Array#last? I mean some_array[-1] also only returns a value. But you don't
have a problem with people being able to write some_array[-1] = some_value
do you?

 

[Sebastian Hungerecker]

It's tempting to treat #first / #last as 0 / -1, but in
actuality they are method calls and simply return a value

Ok, I'm confused. You seem to be saying that first and last are different than
using [] because they are methods and return a value, right? Does that mean
that you mean to imply that Array#[] is not a method or that it doesn't return
a value?
I'm asking because it is starting to look to me like that is what you're
saying, but Array#[] most certainly is a method and it most certainly does
return a value.

 

[bbiker]

Hi,

just today I came across a situation where I needed Array#last=
because I wanted to do

an_array.last += 1

Does anybody else see this as useful?  Any issues with this?  If not
I'll open an RCR.

Kind regards

robert

There's already array#last and array#first

you csn do what you want with an_array[0] and an_array[-1]

irb(main):006:0> an_array = [3, 5, 7, 11, 9, 2]
=> [3, 5, 7, 11, 9, 2]
irb(main):007:0> an_array.last
=> 2
irb(main):008:0> an_array.first
=> 3
irb(main):009:0> an_array[0] = 19
=> 19
irb(main):010:0> an_array[-1] = 1
=> 1
irb(main):011:0> an_array.last
=> 1
irb(main):012:0> an_array.first
=> 19
irb(main):013:0>

 

[bbiker]

On Dec 27, 9:55 am, Sebastian Hungerecker <[email protected]>
wrote:
George wrote:
What would you expect this to do?
  [].last = 1
The same thing as "[][-1] = 1", I'd imagine.
The problem I'm seeing would be this: If you allow arr.last = x, you'd also
have to allow arr.last(n) = x if you want to be consistent, but that's not
syntactically possible.
--
NP: Katatonia - Endtime
Jabber: (e-mail address removed)
ICQ: 205544826
Agree. It's tempting to treat #first / #last as 0 / -1, but in
actuality they are method calls and simply return a value; they don't
subscript an array. Setting #last is not semantically different than
[1,2,3].pop = 4, it's just that #last is just a bit more subtle.

I don't see what you are getting at here. #pop is destructive, #last
is not. What does #last return when it is called? It returns a
reference to the last element. So why would #last= do anything other
then set the reference of the last element? Seems obvious to me. So we
can't do last(n) = x, due to syntax constraints, oh well. It would
still be convenient to have the obvious n=1, no arg case. I find that
my programs are usually easier to read when I can use words rather non-
alphabetic symbols.

T.

IOW, #pop returns a value, and this is just what #last does. One could
argue that #last and #[-1] *should be* synonymous (which may be the
point of the proposal); but as it currently stands, #last means the
same thing as `def l(a); a[-1]; end` so it makes no sense to have a
setter for it. Unless the semantics change, (to me at least) it is non-
sense to have #last=. It's the same as a.pop = 3.

Regards,
Jordan- Hide quoted text -

- Show quoted text -

no it is not!

irb(main):018:0> p an_array
[19, 5, 7, 11, 9, 3]
=> nil
irb(main):019:0> an_array.last
=> 3
irb(main):020:0> p an_array
[19, 5, 7, 11, 9, 3]
=> nil
irb(main):022:0> an_array.pop
=> 3
irb(main):023:0> p an_array
[19, 5, 7, 11, 9]
=> nil

Note that pop actually removes the last item

irb(main):025:0* an_array.pop = 3
NoMethodError: undefined method `pop=' for [19, 5, 7, 11, 9]:Array
from (irb):25

irb(main):029:0> p an_array
[19, 5, 7, 11, 10]
=> nil
irb(main):030:0> an_array[-1] += 1
=> 11
irb(main):031:0> p an_array
[19, 5, 7, 11, 11]

There's is no need for Array#last= or Array#first=

since you can simply use an_array[-1] += 1 or an_array[0] += 1

 

[Sebastian Hungerecker]

There's is no need for Array#last= or Array#first=

since you can simply use an_array[-1] += 1 or an_array[0] += 1

There is no need for Array#last or Array#first
since you can simply use an_array[-1] or an_array[0]

 

[Robert Klemme]

On Dec 27, 9:55 am, Sebastian Hungerecker <[email protected]>
wrote:
George wrote:
What would you expect this to do?
[].last = 1
The same thing as "[][-1] = 1", I'd imagine.
The problem I'm seeing would be this: If you allow arr.last = x, you'd also
have to allow arr.last(n) = x if you want to be consistent, but that's not
syntactically possible.
--
NP: Katatonia - Endtime
Jabber: (e-mail address removed)
ICQ: 205544826
Agree. It's tempting to treat #first / #last as 0 / -1, but in
actuality they are method calls and simply return a value; they don't
subscript an array. Setting #last is not semantically different than
[1,2,3].pop = 4, it's just that #last is just a bit more subtle.

I don't see what you are getting at here. #pop is destructive, #last
is not. What does #last return when it is called? It returns a
reference to the last element. So why would #last= do anything other
then set the reference of the last element? Seems obvious to me. So we
can't do last(n) = x, due to syntax constraints, oh well. It would
still be convenient to have the obvious n=1, no arg case. I find that
my programs are usually easier to read when I can use words rather non-
alphabetic symbols.

T.

IOW, #pop returns a value, and this is just what #last does. One could
argue that #last and #[-1] *should be* synonymous (which may be the
point of the proposal); but as it currently stands, #last means the
same thing as `def l(a); a[-1]; end` so it makes no sense to have a
setter for it.

This is getting weirder and weirder. I do not follow your argument here
at all. If you say that #last is synonymous to [-1] then it would make
even more sense to make #last= synonymous to [-1]=.

Unless the semantics change, (to me at least) it is non-
sense to have #last=. It's the same as a.pop = 3.

Definitively not, as has been pointed out: pop is destructive, last is not.

robert

 

[Robert Klemme]

There's is no need for Array#last= or Array#first=

since you can simply use an_array[-1] += 1 or an_array[0] += 1

There is no need for Array#last or Array#first
since you can simply use an_array[-1] or an_array[0]

With the same argument you can throw out a lot of library methods
because there is "no need" for them. I do not count that as an argument
against.

Cheers

robert

 

[Robert Klemme]

What would you expect this to do?
[].last = 1

The same thing as "[][-1] = 1", I'd imagine.
The problem I'm seeing would be this: If you allow arr.last = x, you'd also
have to allow arr.last(n) = x if you want to be consistent, but that's not
syntactically possible.

I do not see why allowing last= would make lasts(n)= necessary.
Array#last and Array#first index exactly one argument - no need for
additional indexing.

Agree. It's tempting to treat #first / #last as 0 / -1, but in
actuality they are method calls and simply return a value; they don't
subscript an array.

Array#[] and Array#[]= are method calls as well.

Setting #last is not semantically different than
[1,2,3].pop = 4, it's just that #last is just a bit more subtle.

#last is non destructive while #pop is destructive. Not the same.

Regards

robert

 

[Marc Heiler]

There is no need for Array#last or Array#first

since you can simply use an_array[-1] or an_array[0]

I think if you combine this with that here (about .last and .first)

I find that my programs are usually easier to read when I can
use words rather non-alphabetic symbols.

(I believe he meant numbers... "non-alphabetic symbols" sounds weird to
me, and maybe slightly confusing as ruby has :symbols too ... )

then it would become more obvious as to the _why_ about this suggestion.

But this discussion seems to have it's own waves, maybe we should
wait for Robert to write something about it since he kinda started this

 

[Robert Klemme]

Hi,

just today I came across a situation where I needed Array#last=
because I wanted to do

an_array.last += 1

Does anybody else see this as useful? Any issues with this? If not
I'll open an RCR.

Kind regards

robert

There's already array#last and array#first

you csn do what you want with an_array[0] and an_array[-1]

Well, yes. But I don't want to. Instead I'd rather use last= and
first= in some circumstances much the same way as I sometimes rather use
last and first instead of [0] and [-1].

So far the only argument against I have seen so far is the question
about assignment to an empty array. In that case I'd say, either raise
an exception or silently add the element. Have to think about this a bit.

Cheers

robert

 

[Yu-raku-an]

Hi, Robert,

In this case, I think the best way for you is to do it by yourself.
You can override an existing class in Ruby, even the one is a standard
library class.

Provide a source file containing:

class Array
def first=(v)
self[0] = v
end

def last=(v)
self[-1] = v
end
end

and require it as you like.
And then you can use Array#first= and Array#last= as other standard
methods for the class.

Yu-raku-an.

Hi,

just today I came across a situation where I needed Array#last=
because I wanted to do

an_array.last += 1

Does anybody else see this as useful? Any issues with this? If not
I'll open an RCR.

Kind regards

robert

There's already array#last and array#first

you csn do what you want with an_array[0] and an_array[-1]

Well, yes. But I don't want to. Instead I'd rather use last= and
first= in some circumstances much the same way as I sometimes rather use
last and first instead of [0] and [-1].

So far the only argument against I have seen so far is the question
about assignment to an empty array. In that case I'd say, either raise
an exception or silently add the element. Have to think about this a bit.

Cheers

robert