I've been thinking about this for
a half hour or so.

Rather than writing this kind of thing:

  str[x,y] = str[x,y].reverse
  str[x..z] = str[x..z].reverse

I'd like to be able to do this:

  str[x,y].reverse!
  str[x..z].reverse!

There is probably some good reason this
won't work, though. ;)

Someone care to comment?

Hal

Implementation problems.  The reverse! must be sent to some object --
presumably a "Substring" object that can modify the string it
contains.  But I'm not sure str#[] should return a non-String.

I would love a Substring class, as it would make some of the things I
have done in the past easier to write and more efficient.  But
sometimes I would want modifications to self to modify the owning
string, sometimes not.

--
matt

The current semantics are that this:

     str[x, y] = ... some string ...

modifies str in place, but this:

     str[x, y]

returns a *new* String object (and that's the clincher) which is a slice
from 'str'.

So if str[x, y] returns a new String, then I would *expect* that

     str[x, y].reverse!

instantiates a new String, then calls String#reverse! to perform an
in-place reverse on that new string -- but still leaves the original
string (str) unmodified.

Hi,

At Thu, 13 Feb 2003 09:13:35 +0900,

Agree, and also Array#reverse.

--
Nobu Nakada

Hi,

In message "Should substrings be modifiable in-place??"

|  str[x,y] = str[x,y].reverse
|  str[x..z] = str[x..z].reverse
|
|I'd like to be able to do this:
|
|  str[x,y].reverse!
|  str[x..z].reverse!
|
|There is probably some good reason this
|won't work, though. ;)

It introduces too tight relationship between str and what str[x,y]
returns.  str.reverse!(x,y) is much better, although I'm not sure if
it's worth implementing it to save a dozen keystrokes.  How often do
we need to reverse substring?

                                                        matz.

I guess the reality is: Not very often.
This was more a question of "how should
things work?"

It has been a long time since I wrote an
expression in Ruby and it didn't do what
I wanted. :) I mean, I do introduce bugs,
but lately they are usually a malfunction
of my brain rather than a misunderstanding
of Ruby.

This issue is unimportant. But thanks for
replying, and I see your reasoning.

Hal

class String
  instance_methods.select {|i| i =~ /!$/}.each {|m|
    module_eval <<-here
    def s#{m}(*args)
      a = args.shift
      if (Range === a)
        a, b = a.first, a.last
      else
        b = args.shift
      end
      c = self[a,b]
      self[a,b] = c.send(:#{m},*args)
    end
    here
  }
end

a = "hello world"
a.sreverse!(3,7)
p a #==> "hellrow old"
a.sgsub!(0,5,/l/,'p')
p a #==> "hepprow old"