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

Discussion in 'Ruby' started by Robert Klemme, Dec 27, 2007.

  1. 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

    --
    use.inject do |as, often| as.you_can - without end
     
    Robert Klemme, Dec 27, 2007
    #1
    1. Advertising

  2. Robert Klemme

    Joe Guest

    Is there a problem with doing something like this:

    an_array[-1] += 1

    Joe

    On Dec 27, 2007 4:59 AM, Robert Klemme <> wrote:
    > 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
    >
    > --
    > use.inject do |as, often| as.you_can - without end
    >
    >
     
    Joe, Dec 27, 2007
    #2
    1. Advertising

  3. Robert Klemme

    George Guest

    On Dec 27, 2007 8:59 PM, Robert Klemme <> wrote:
    > 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.
     
    George, Dec 27, 2007
    #3
  4. George wrote:
    > 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:
    ICQ: 205544826
     
    Sebastian Hungerecker, Dec 27, 2007
    #4
  5. Robert Klemme

    MonkeeSage Guest

    On Dec 27, 9:55 am, Sebastian Hungerecker <>
    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:
    > 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.

    Regards,
    Jordan
     
    MonkeeSage, Dec 27, 2007
    #5
  6. Robert Klemme

    Trans Guest

    On Dec 27, 12:54 pm, MonkeeSage <> wrote:
    > On Dec 27, 9:55 am, Sebastian Hungerecker <>
    > 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:
    > > 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.
     
    Trans, Dec 27, 2007
    #6
  7. Robert Klemme

    MonkeeSage Guest

    On Dec 27, 12:52 pm, Trans <> wrote:
    > On Dec 27, 12:54 pm, MonkeeSage <> wrote:
    >
    >
    >
    > > On Dec 27, 9:55 am, Sebastian Hungerecker <>
    > > 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:
    > > > 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
     
    MonkeeSage, Dec 27, 2007
    #7
  8. MonkeeSage wrote:
    > IOW, #pop returns a value, and this is just what #last does.


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


    --
    Jabber:
    ICQ: 205544826
     
    Sebastian Hungerecker, Dec 27, 2007
    #8
  9. Robert Klemme

    MonkeeSage Guest

    On Dec 27, 1:38 pm, Sebastian Hungerecker <>
    wrote:
    > MonkeeSage wrote:
    > > IOW, #pop returns a value, and this is just what #last does.

    >
    > How is [] different in that regard? That only returns a value, too.
    >
    > --
    > Jabber:
    > ICQ: 205544826


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

    Regards,
    Jordan
     
    MonkeeSage, Dec 27, 2007
    #9
  10. MonkeeSage wrote:
    > On Dec 27, 1:38 pm, Sebastian Hungerecker wrote:
    > > MonkeeSage wrote:
    > > > 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?


    --
    Jabber:
    ICQ: 205544826
     
    Sebastian Hungerecker, Dec 27, 2007
    #10
  11. MonkeeSage wrote:
    > 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.


    --
    NP: Jon Oliva's Pain - Walk Alone
    Jabber:
    ICQ: 205544826
     
    Sebastian Hungerecker, Dec 27, 2007
    #11
  12. Robert Klemme

    bbiker Guest

    On Dec 27, 4:59 am, Robert Klemme <> wrote:
    > 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
    >
    > --
    > use.inject do |as, often| as.you_can - without end


    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, Dec 27, 2007
    #12
  13. Robert Klemme

    bbiker Guest

    On Dec 27, 2:15 pm, MonkeeSage <> wrote:
    > On Dec 27, 12:52 pm, Trans <> wrote:
    >
    >
    >
    >
    >
    > > On Dec 27, 12:54 pm, MonkeeSage <> wrote:

    >
    > > > On Dec 27, 9:55 am, Sebastian Hungerecker <>
    > > > 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:
    > > > > 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
     
    bbiker, Dec 27, 2007
    #13
  14. bbiker wrote:
    > 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]

    --
    Jabber:
    ICQ: 205544826
     
    Sebastian Hungerecker, Dec 27, 2007
    #14
  15. On 27.12.2007 20:15, MonkeeSage wrote:
    > On Dec 27, 12:52 pm, Trans <> wrote:
    >> On Dec 27, 12:54 pm, MonkeeSage <> wrote:
    >>
    >>
    >>
    >>> On Dec 27, 9:55 am, Sebastian Hungerecker <>
    >>> 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:
    >>>> 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, Dec 27, 2007
    #15
  16. On 27.12.2007 22:58, Sebastian Hungerecker wrote:
    > bbiker wrote:
    >> 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, Dec 27, 2007
    #16
  17. On 27.12.2007 18:53, MonkeeSage wrote:
    > On Dec 27, 9:55 am, Sebastian Hungerecker <>
    > 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.


    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
     
    Robert Klemme, Dec 27, 2007
    #17
  18. Robert Klemme

    Marc Heiler Guest

    > 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
    :)
    --
    Posted via http://www.ruby-forum.com/.
     
    Marc Heiler, Dec 27, 2007
    #18
  19. On 27.12.2007 22:18, bbiker wrote:
    > On Dec 27, 4:59 am, Robert Klemme <> wrote:
    >> 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
    >>
    >> --
    >> use.inject do |as, often| as.you_can - without end

    >
    > 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
     
    Robert Klemme, Dec 27, 2007
    #19
  20. Robert Klemme

    Yu-raku-an Guest

    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.


    Robert Klemme wrote:
    > On 27.12.2007 22:18, bbiker wrote:
    >> On Dec 27, 4:59 am, Robert Klemme <> wrote:
    >>> 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
    >>>
    >>> --
    >>> use.inject do |as, often| as.you_can - without end

    >>
    >> 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
    >
    >
    >


    --------------------------------------
    Easy + Joy + Powerful = Yahoo! Bookmarks x Toolbar
    http://pr.mail.yahoo.co.jp/toolbar/
     
    Yu-raku-an, Dec 28, 2007
    #20
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.

Share This Page